code
stringlengths 3
10M
| language
stringclasses 31
values |
|---|---|
/**
* The atomic module provides basic support for lock-free
* concurrent programming.
*
* Copyright: Copyright Sean Kelly 2005 - 2010.
* License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Authors: Sean Kelly, Alex Rønne Petersen
* Source: $(DRUNTIMESRC core/_atomic.d)
*/
/* Copyright Sean Kelly 2005 - 2010.
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*/
module core.atomic;
version( D_InlineAsm_X86 )
{
version = AsmX86;
version = AsmX86_32;
enum has64BitCAS = true;
enum has128BitCAS = false;
}
else version( D_InlineAsm_X86_64 )
{
version = AsmX86;
version = AsmX86_64;
enum has64BitCAS = true;
enum has128BitCAS = true;
}
else
{
enum has64BitCAS = false;
enum has128BitCAS = false;
}
private
{
template HeadUnshared(T)
{
static if( is( T U : shared(U*) ) )
alias shared(U)* HeadUnshared;
else
alias T HeadUnshared;
}
}
version( AsmX86 )
{
// NOTE: Strictly speaking, the x86 supports atomic operations on
// unaligned values. However, this is far slower than the
// common case, so such behavior should be prohibited.
private bool atomicValueIsProperlyAligned(T)( size_t addr ) pure nothrow
{
return addr % T.sizeof == 0;
}
}
version( CoreDdoc )
{
/**
* Performs the binary operation 'op' on val using 'mod' as the modifier.
*
* Params:
* val = The target variable.
* mod = The modifier to apply.
*
* Returns:
* The result of the operation.
*/
HeadUnshared!(T) atomicOp(string op, T, V1)( ref shared T val, V1 mod ) pure nothrow @nogc
if( __traits( compiles, mixin( "*cast(T*)&val" ~ op ~ "mod" ) ) )
{
return HeadUnshared!(T).init;
}
/**
* Stores 'writeThis' to the memory referenced by 'here' if the value
* referenced by 'here' is equal to 'ifThis'. This operation is both
* lock-free and atomic.
*
* Params:
* here = The address of the destination variable.
* writeThis = The value to store.
* ifThis = The comparison value.
*
* Returns:
* true if the store occurred, false if not.
*/
bool cas(T,V1,V2)( shared(T)* here, const V1 ifThis, V2 writeThis ) pure nothrow @nogc
if( !is(T == class) && !is(T U : U*) && __traits( compiles, { *here = writeThis; } ) );
/// Ditto
bool cas(T,V1,V2)( shared(T)* here, const shared(V1) ifThis, shared(V2) writeThis ) pure nothrow @nogc
if( is(T == class) && __traits( compiles, { *here = writeThis; } ) );
/// Ditto
bool cas(T,V1,V2)( shared(T)* here, const shared(V1)* ifThis, shared(V2)* writeThis ) pure nothrow @nogc
if( is(T U : U*) && __traits( compiles, { *here = writeThis; } ) );
/**
* Loads 'val' from memory and returns it. The memory barrier specified
* by 'ms' is applied to the operation, which is fully sequenced by
* default.
*
* Params:
* val = The target variable.
*
* Returns:
* The value of 'val'.
*/
HeadUnshared!(T) atomicLoad(MemoryOrder ms = MemoryOrder.seq,T)( ref const shared T val ) pure nothrow @nogc
{
return HeadUnshared!(T).init;
}
/**
* Writes 'newval' into 'val'. The memory barrier specified by 'ms' is
* applied to the operation, which is fully sequenced by default.
*
* Params:
* val = The target variable.
* newval = The value to store.
*/
void atomicStore(MemoryOrder ms = MemoryOrder.seq,T,V1)( ref shared T val, V1 newval ) pure nothrow @nogc
if( __traits( compiles, { val = newval; } ) )
{
}
/**
* Specifies the memory ordering semantics of an atomic operation.
*/
enum MemoryOrder
{
raw, /// Not sequenced.
acq, /// Hoist-load + hoist-store barrier.
rel, /// Sink-load + sink-store barrier.
seq, /// Fully sequenced (acquire + release).
}
deprecated("Please use MemoryOrder instead.")
alias MemoryOrder msync;
/**
* Inserts a full load/store memory fence (on platforms that need it). This ensures
* that all loads and stores before a call to this function are executed before any
* loads and stores after the call.
*/
void atomicFence() nothrow @nogc;
}
else version( AsmX86_32 )
{
// Uses specialized asm for fast fetch and add operations
private HeadUnshared!(T) atomicFetchAdd(T, V1)( ref shared T val, V1 mod ) pure nothrow @nogc
if( T.sizeof <= 4 && V1.sizeof <= 4)
{
size_t tmp = mod; // convert all operands to size_t
asm pure nothrow @nogc
{
mov EAX, tmp;
mov EDX, val;
}
static if (T.sizeof == 1) asm pure nothrow @nogc { lock; xadd[EDX], AL; }
else static if (T.sizeof == 2) asm pure nothrow @nogc { lock; xadd[EDX], AX; }
else static if (T.sizeof == 4) asm pure nothrow @nogc { lock; xadd[EDX], EAX; }
asm pure nothrow @nogc
{
mov tmp, EAX;
}
return cast(T)tmp;
}
private HeadUnshared!(T) atomicFetchSub(T, V1)( ref shared T val, V1 mod ) pure nothrow @nogc
if( T.sizeof <= 4 && V1.sizeof <= 4)
{
return atomicFetchAdd(val, -mod);
}
HeadUnshared!(T) atomicOp(string op, T, V1)( ref shared T val, V1 mod ) pure nothrow @nogc
if( __traits( compiles, mixin( "*cast(T*)&val" ~ op ~ "mod" ) ) )
in
{
// NOTE: 32 bit x86 systems support 8 byte CAS, which only requires
// 4 byte alignment, so use size_t as the align type here.
static if( T.sizeof > size_t.sizeof )
assert( atomicValueIsProperlyAligned!(size_t)( cast(size_t) &val ) );
else
assert( atomicValueIsProperlyAligned!(T)( cast(size_t) &val ) );
}
body
{
// binary operators
//
// + - * / % ^^ &
// | ^ << >> >>> ~ in
// == != < <= > >=
static if( op == "+" || op == "-" || op == "*" || op == "/" ||
op == "%" || op == "^^" || op == "&" || op == "|" ||
op == "^" || op == "<<" || op == ">>" || op == ">>>" ||
op == "~" || // skip "in"
op == "==" || op == "!=" || op == "<" || op == "<=" ||
op == ">" || op == ">=" )
{
HeadUnshared!(T) get = atomicLoad!(MemoryOrder.raw)( val );
mixin( "return get " ~ op ~ " mod;" );
}
else
// assignment operators
//
// += -= *= /= %= ^^= &=
// |= ^= <<= >>= >>>= ~=
static if( op == "+=" && __traits(isIntegral, T) && T.sizeof <= 4 && V1.sizeof <= 4)
{
return cast(T)(atomicFetchAdd!(T)(val, mod) + mod);
}
else static if( op == "-=" && __traits(isIntegral, T) && T.sizeof <= 4 && V1.sizeof <= 4)
{
return cast(T)(atomicFetchSub!(T)(val, mod) - mod);
}
else static if( op == "+=" || op == "-=" || op == "*=" || op == "/=" ||
op == "%=" || op == "^^=" || op == "&=" || op == "|=" ||
op == "^=" || op == "<<=" || op == ">>=" || op == ">>>=" ) // skip "~="
{
HeadUnshared!(T) get, set;
do
{
get = set = atomicLoad!(MemoryOrder.raw)( val );
mixin( "set " ~ op ~ " mod;" );
} while( !cas( &val, get, set ) );
return set;
}
else
{
static assert( false, "Operation not supported." );
}
}
bool cas(T,V1,V2)( shared(T)* here, const V1 ifThis, V2 writeThis ) pure nothrow @nogc
if( !is(T == class) && !is(T U : U*) && __traits( compiles, { *here = writeThis; } ) )
{
return casImpl(here, ifThis, writeThis);
}
bool cas(T,V1,V2)( shared(T)* here, const shared(V1) ifThis, shared(V2) writeThis ) pure nothrow @nogc
if( is(T == class) && __traits( compiles, { *here = writeThis; } ) )
{
return casImpl(here, ifThis, writeThis);
}
bool cas(T,V1,V2)( shared(T)* here, const shared(V1)* ifThis, shared(V2)* writeThis ) pure nothrow @nogc
if( is(T U : U*) && __traits( compiles, { *here = writeThis; } ) )
{
return casImpl(here, ifThis, writeThis);
}
private bool casImpl(T,V1,V2)( shared(T)* here, V1 ifThis, V2 writeThis ) pure nothrow @nogc
in
{
// NOTE: 32 bit x86 systems support 8 byte CAS, which only requires
// 4 byte alignment, so use size_t as the align type here.
static if( T.sizeof > size_t.sizeof )
assert( atomicValueIsProperlyAligned!(size_t)( cast(size_t) here ) );
else
assert( atomicValueIsProperlyAligned!(T)( cast(size_t) here ) );
}
body
{
static if( T.sizeof == byte.sizeof )
{
//////////////////////////////////////////////////////////////////
// 1 Byte CAS
//////////////////////////////////////////////////////////////////
asm pure nothrow @nogc
{
mov DL, writeThis;
mov AL, ifThis;
mov ECX, here;
lock; // lock always needed to make this op atomic
cmpxchg [ECX], DL;
setz AL;
}
}
else static if( T.sizeof == short.sizeof )
{
//////////////////////////////////////////////////////////////////
// 2 Byte CAS
//////////////////////////////////////////////////////////////////
asm pure nothrow @nogc
{
mov DX, writeThis;
mov AX, ifThis;
mov ECX, here;
lock; // lock always needed to make this op atomic
cmpxchg [ECX], DX;
setz AL;
}
}
else static if( T.sizeof == int.sizeof )
{
//////////////////////////////////////////////////////////////////
// 4 Byte CAS
//////////////////////////////////////////////////////////////////
asm pure nothrow @nogc
{
mov EDX, writeThis;
mov EAX, ifThis;
mov ECX, here;
lock; // lock always needed to make this op atomic
cmpxchg [ECX], EDX;
setz AL;
}
}
else static if( T.sizeof == long.sizeof && has64BitCAS )
{
//////////////////////////////////////////////////////////////////
// 8 Byte CAS on a 32-Bit Processor
//////////////////////////////////////////////////////////////////
asm pure nothrow @nogc
{
push EDI;
push EBX;
lea EDI, writeThis;
mov EBX, [EDI];
mov ECX, 4[EDI];
lea EDI, ifThis;
mov EAX, [EDI];
mov EDX, 4[EDI];
mov EDI, here;
lock; // lock always needed to make this op atomic
cmpxchg8b [EDI];
setz AL;
pop EBX;
pop EDI;
}
}
else
{
static assert( false, "Invalid template type specified." );
}
}
enum MemoryOrder
{
raw,
acq,
rel,
seq,
}
deprecated("Please use MemoryOrder instead.")
alias MemoryOrder msync;
private
{
template isHoistOp(MemoryOrder ms)
{
enum bool isHoistOp = ms == MemoryOrder.acq ||
ms == MemoryOrder.seq;
}
template isSinkOp(MemoryOrder ms)
{
enum bool isSinkOp = ms == MemoryOrder.rel ||
ms == MemoryOrder.seq;
}
// NOTE: x86 loads implicitly have acquire semantics so a memory
// barrier is only necessary on releases.
template needsLoadBarrier( MemoryOrder ms )
{
enum bool needsLoadBarrier = ms == MemoryOrder.seq ||
isSinkOp!(ms);
}
// NOTE: x86 stores implicitly have release semantics so a memory
// barrier is only necessary on acquires.
template needsStoreBarrier( MemoryOrder ms )
{
enum bool needsStoreBarrier = ms == MemoryOrder.seq ||
isHoistOp!(ms);
}
}
HeadUnshared!(T) atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)( ref const shared T val ) pure nothrow @nogc
if(!__traits(isFloating, T))
{
static if (!__traits(isPOD, T))
{
static assert( false, "argument to atomicLoad() must be POD" );
}
else static if( T.sizeof == byte.sizeof )
{
//////////////////////////////////////////////////////////////////
// 1 Byte Load
//////////////////////////////////////////////////////////////////
static if( needsLoadBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov DL, 0;
mov AL, 0;
mov ECX, val;
lock; // lock always needed to make this op atomic
cmpxchg [ECX], DL;
}
}
else
{
asm pure nothrow @nogc
{
mov EAX, val;
mov AL, [EAX];
}
}
}
else static if( T.sizeof == short.sizeof )
{
//////////////////////////////////////////////////////////////////
// 2 Byte Load
//////////////////////////////////////////////////////////////////
static if( needsLoadBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov DX, 0;
mov AX, 0;
mov ECX, val;
lock; // lock always needed to make this op atomic
cmpxchg [ECX], DX;
}
}
else
{
asm pure nothrow @nogc
{
mov EAX, val;
mov AX, [EAX];
}
}
}
else static if( T.sizeof == int.sizeof )
{
//////////////////////////////////////////////////////////////////
// 4 Byte Load
//////////////////////////////////////////////////////////////////
static if( needsLoadBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov EDX, 0;
mov EAX, 0;
mov ECX, val;
lock; // lock always needed to make this op atomic
cmpxchg [ECX], EDX;
}
}
else
{
asm pure nothrow @nogc
{
mov EAX, val;
mov EAX, [EAX];
}
}
}
else static if( T.sizeof == long.sizeof && has64BitCAS )
{
//////////////////////////////////////////////////////////////////
// 8 Byte Load on a 32-Bit Processor
//////////////////////////////////////////////////////////////////
asm pure nothrow @nogc
{
push EDI;
push EBX;
mov EBX, 0;
mov ECX, 0;
mov EAX, 0;
mov EDX, 0;
mov EDI, val;
lock; // lock always needed to make this op atomic
cmpxchg8b [EDI];
pop EBX;
pop EDI;
}
}
else
{
static assert( false, "Invalid template type specified." );
}
}
void atomicStore(MemoryOrder ms = MemoryOrder.seq, T, V1)( ref shared T val, V1 newval ) pure nothrow @nogc
if( __traits( compiles, { val = newval; } ) )
{
static if( T.sizeof == byte.sizeof )
{
//////////////////////////////////////////////////////////////////
// 1 Byte Store
//////////////////////////////////////////////////////////////////
static if( needsStoreBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov EAX, val;
mov DL, newval;
lock;
xchg [EAX], DL;
}
}
else
{
asm pure nothrow @nogc
{
mov EAX, val;
mov DL, newval;
mov [EAX], DL;
}
}
}
else static if( T.sizeof == short.sizeof )
{
//////////////////////////////////////////////////////////////////
// 2 Byte Store
//////////////////////////////////////////////////////////////////
static if( needsStoreBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov EAX, val;
mov DX, newval;
lock;
xchg [EAX], DX;
}
}
else
{
asm pure nothrow @nogc
{
mov EAX, val;
mov DX, newval;
mov [EAX], DX;
}
}
}
else static if( T.sizeof == int.sizeof )
{
//////////////////////////////////////////////////////////////////
// 4 Byte Store
//////////////////////////////////////////////////////////////////
static if( needsStoreBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov EAX, val;
mov EDX, newval;
lock;
xchg [EAX], EDX;
}
}
else
{
asm pure nothrow @nogc
{
mov EAX, val;
mov EDX, newval;
mov [EAX], EDX;
}
}
}
else static if( T.sizeof == long.sizeof && has64BitCAS )
{
//////////////////////////////////////////////////////////////////
// 8 Byte Store on a 32-Bit Processor
//////////////////////////////////////////////////////////////////
asm pure nothrow @nogc
{
push EDI;
push EBX;
lea EDI, newval;
mov EBX, [EDI];
mov ECX, 4[EDI];
mov EDI, val;
mov EAX, [EDI];
mov EDX, 4[EDI];
L1: lock; // lock always needed to make this op atomic
cmpxchg8b [EDI];
jne L1;
pop EBX;
pop EDI;
}
}
else
{
static assert( false, "Invalid template type specified." );
}
}
void atomicFence() nothrow
{
import core.cpuid;
asm pure nothrow @nogc
{
naked;
call sse2;
test AL, AL;
jne Lcpuid;
// Fast path: We have SSE2, so just use mfence.
mfence;
jmp Lend;
Lcpuid:
// Slow path: We use cpuid to serialize. This is
// significantly slower than mfence, but is the
// only serialization facility we have available
// on older non-SSE2 chips.
push EBX;
mov EAX, 0;
cpuid;
pop EBX;
Lend:
ret;
}
}
}
else version( AsmX86_64 )
{
// Uses specialized asm for fast fetch and add operations
private HeadUnshared!(T) atomicFetchAdd(T, V1)( ref shared T val, V1 mod ) pure nothrow @nogc
if( __traits(isIntegral, T) && __traits(isIntegral, V1) )
in
{
// NOTE: 32 bit x86 systems support 8 byte CAS, which only requires
// 4 byte alignment, so use size_t as the align type here.
static if( T.sizeof > size_t.sizeof )
assert( atomicValueIsProperlyAligned!(size_t)( cast(size_t) &val ) );
else
assert( atomicValueIsProperlyAligned!(T)( cast(size_t) &val ) );
}
body
{
size_t tmp = mod; // convert all operands to size_t
asm pure nothrow @nogc
{
mov RAX, tmp;
mov RDX, val;
}
static if (T.sizeof == 1) asm pure nothrow @nogc { lock; xadd[RDX], AL; }
else static if (T.sizeof == 2) asm pure nothrow @nogc { lock; xadd[RDX], AX; }
else static if (T.sizeof == 4) asm pure nothrow @nogc { lock; xadd[RDX], EAX; }
else static if (T.sizeof == 8) asm pure nothrow @nogc { lock; xadd[RDX], RAX; }
asm pure nothrow @nogc
{
mov tmp, RAX;
}
return cast(T)tmp;
}
private HeadUnshared!(T) atomicFetchSub(T, V1)( ref shared T val, V1 mod ) pure nothrow @nogc
if( __traits(isIntegral, T) && __traits(isIntegral, V1) )
{
return atomicFetchAdd(val, -mod);
}
HeadUnshared!(T) atomicOp(string op, T, V1)( ref shared T val, V1 mod ) pure nothrow @nogc
if( __traits( compiles, mixin( "*cast(T*)&val" ~ op ~ "mod" ) ) )
in
{
// NOTE: 32 bit x86 systems support 8 byte CAS, which only requires
// 4 byte alignment, so use size_t as the align type here.
static if( T.sizeof > size_t.sizeof )
assert( atomicValueIsProperlyAligned!(size_t)( cast(size_t) &val ) );
else
assert( atomicValueIsProperlyAligned!(T)( cast(size_t) &val ) );
}
body
{
// binary operators
//
// + - * / % ^^ &
// | ^ << >> >>> ~ in
// == != < <= > >=
static if( op == "+" || op == "-" || op == "*" || op == "/" ||
op == "%" || op == "^^" || op == "&" || op == "|" ||
op == "^" || op == "<<" || op == ">>" || op == ">>>" ||
op == "~" || // skip "in"
op == "==" || op == "!=" || op == "<" || op == "<=" ||
op == ">" || op == ">=" )
{
HeadUnshared!(T) get = atomicLoad!(MemoryOrder.raw)( val );
mixin( "return get " ~ op ~ " mod;" );
}
else
// assignment operators
//
// += -= *= /= %= ^^= &=
// |= ^= <<= >>= >>>= ~=
static if( op == "+=" && __traits(isIntegral, T) && __traits(isIntegral, V1))
{
return cast(T)(atomicFetchAdd!(T)(val, mod) + mod);
}
else static if( op == "-=" && __traits(isIntegral, T) && __traits(isIntegral, V1))
{
return cast(T)(atomicFetchSub!(T)(val, mod) - mod);
}
else static if( op == "+=" || op == "-=" || op == "*=" || op == "/=" ||
op == "%=" || op == "^^=" || op == "&=" || op == "|=" ||
op == "^=" || op == "<<=" || op == ">>=" || op == ">>>=" ) // skip "~="
{
HeadUnshared!(T) get, set;
do
{
get = set = atomicLoad!(MemoryOrder.raw)( val );
mixin( "set " ~ op ~ " mod;" );
} while( !cas( &val, get, set ) );
return set;
}
else
{
static assert( false, "Operation not supported." );
}
}
bool cas(T,V1,V2)( shared(T)* here, const V1 ifThis, V2 writeThis ) pure nothrow @nogc
if( !is(T == class) && !is(T U : U*) && __traits( compiles, { *here = writeThis; } ) )
{
return casImpl(here, ifThis, writeThis);
}
bool cas(T,V1,V2)( shared(T)* here, const shared(V1) ifThis, shared(V2) writeThis ) pure nothrow @nogc
if( is(T == class) && __traits( compiles, { *here = writeThis; } ) )
{
return casImpl(here, ifThis, writeThis);
}
bool cas(T,V1,V2)( shared(T)* here, const shared(V1)* ifThis, shared(V2)* writeThis ) pure nothrow @nogc
if( is(T U : U*) && __traits( compiles, { *here = writeThis; } ) )
{
return casImpl(here, ifThis, writeThis);
}
private bool casImpl(T,V1,V2)( shared(T)* here, V1 ifThis, V2 writeThis ) pure nothrow @nogc
in
{
// NOTE: 32 bit x86 systems support 8 byte CAS, which only requires
// 4 byte alignment, so use size_t as the align type here.
static if( T.sizeof > size_t.sizeof )
assert( atomicValueIsProperlyAligned!(size_t)( cast(size_t) here ) );
else
assert( atomicValueIsProperlyAligned!(T)( cast(size_t) here ) );
}
body
{
static if( T.sizeof == byte.sizeof )
{
//////////////////////////////////////////////////////////////////
// 1 Byte CAS
//////////////////////////////////////////////////////////////////
asm pure nothrow @nogc
{
mov DL, writeThis;
mov AL, ifThis;
mov RCX, here;
lock; // lock always needed to make this op atomic
cmpxchg [RCX], DL;
setz AL;
}
}
else static if( T.sizeof == short.sizeof )
{
//////////////////////////////////////////////////////////////////
// 2 Byte CAS
//////////////////////////////////////////////////////////////////
asm pure nothrow @nogc
{
mov DX, writeThis;
mov AX, ifThis;
mov RCX, here;
lock; // lock always needed to make this op atomic
cmpxchg [RCX], DX;
setz AL;
}
}
else static if( T.sizeof == int.sizeof )
{
//////////////////////////////////////////////////////////////////
// 4 Byte CAS
//////////////////////////////////////////////////////////////////
asm pure nothrow @nogc
{
mov EDX, writeThis;
mov EAX, ifThis;
mov RCX, here;
lock; // lock always needed to make this op atomic
cmpxchg [RCX], EDX;
setz AL;
}
}
else static if( T.sizeof == long.sizeof )
{
//////////////////////////////////////////////////////////////////
// 8 Byte CAS on a 64-Bit Processor
//////////////////////////////////////////////////////////////////
asm pure nothrow @nogc
{
mov RDX, writeThis;
mov RAX, ifThis;
mov RCX, here;
lock; // lock always needed to make this op atomic
cmpxchg [RCX], RDX;
setz AL;
}
}
else static if( T.sizeof == long.sizeof*2 && has128BitCAS)
{
//////////////////////////////////////////////////////////////////
// 16 Byte CAS on a 64-Bit Processor
//////////////////////////////////////////////////////////////////
version(Win64){
//Windows 64 calling convention uses different registers.
//DMD appears to reverse the register order.
asm pure nothrow @nogc
{
push RDI;
push RBX;
mov R9, writeThis;
mov R10, ifThis;
mov R11, here;
mov RDI, R9;
mov RBX, [RDI];
mov RCX, 8[RDI];
mov RDI, R10;
mov RAX, [RDI];
mov RDX, 8[RDI];
mov RDI, R11;
lock;
cmpxchg16b [RDI];
setz AL;
pop RBX;
pop RDI;
}
}else{
asm pure nothrow @nogc
{
push RDI;
push RBX;
lea RDI, writeThis;
mov RBX, [RDI];
mov RCX, 8[RDI];
lea RDI, ifThis;
mov RAX, [RDI];
mov RDX, 8[RDI];
mov RDI, here;
lock; // lock always needed to make this op atomic
cmpxchg16b [RDI];
setz AL;
pop RBX;
pop RDI;
}
}
}
else
{
static assert( false, "Invalid template type specified." );
}
}
enum MemoryOrder
{
raw,
acq,
rel,
seq,
}
deprecated("Please use MemoryOrder instead.")
alias MemoryOrder msync;
private
{
template isHoistOp(MemoryOrder ms)
{
enum bool isHoistOp = ms == MemoryOrder.acq ||
ms == MemoryOrder.seq;
}
template isSinkOp(MemoryOrder ms)
{
enum bool isSinkOp = ms == MemoryOrder.rel ||
ms == MemoryOrder.seq;
}
// NOTE: x86 loads implicitly have acquire semantics so a memory
// barrier is only necessary on releases.
template needsLoadBarrier( MemoryOrder ms )
{
enum bool needsLoadBarrier = ms == MemoryOrder.seq ||
isSinkOp!(ms);
}
// NOTE: x86 stores implicitly have release semantics so a memory
// barrier is only necessary on acquires.
template needsStoreBarrier( MemoryOrder ms )
{
enum bool needsStoreBarrier = ms == MemoryOrder.seq ||
isHoistOp!(ms);
}
}
HeadUnshared!(T) atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)( ref const shared T val ) pure nothrow @nogc
if(!__traits(isFloating, T)) {
static if( T.sizeof == byte.sizeof )
{
//////////////////////////////////////////////////////////////////
// 1 Byte Load
//////////////////////////////////////////////////////////////////
static if( needsLoadBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov DL, 0;
mov AL, 0;
mov RCX, val;
lock; // lock always needed to make this op atomic
cmpxchg [RCX], DL;
}
}
else
{
asm pure nothrow @nogc
{
mov RAX, val;
mov AL, [RAX];
}
}
}
else static if( T.sizeof == short.sizeof )
{
//////////////////////////////////////////////////////////////////
// 2 Byte Load
//////////////////////////////////////////////////////////////////
static if( needsLoadBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov DX, 0;
mov AX, 0;
mov RCX, val;
lock; // lock always needed to make this op atomic
cmpxchg [RCX], DX;
}
}
else
{
asm pure nothrow @nogc
{
mov RAX, val;
mov AX, [RAX];
}
}
}
else static if( T.sizeof == int.sizeof )
{
//////////////////////////////////////////////////////////////////
// 4 Byte Load
//////////////////////////////////////////////////////////////////
static if( needsLoadBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov EDX, 0;
mov EAX, 0;
mov RCX, val;
lock; // lock always needed to make this op atomic
cmpxchg [RCX], EDX;
}
}
else
{
asm pure nothrow @nogc
{
mov RAX, val;
mov EAX, [RAX];
}
}
}
else static if( T.sizeof == long.sizeof )
{
//////////////////////////////////////////////////////////////////
// 8 Byte Load
//////////////////////////////////////////////////////////////////
static if( needsLoadBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov RDX, 0;
mov RAX, 0;
mov RCX, val;
lock; // lock always needed to make this op atomic
cmpxchg [RCX], RDX;
}
}
else
{
asm pure nothrow @nogc
{
mov RAX, val;
mov RAX, [RAX];
}
}
}
else static if( T.sizeof == long.sizeof*2 && has128BitCAS )
{
//////////////////////////////////////////////////////////////////
// 16 Byte Load on a 64-Bit Processor
//////////////////////////////////////////////////////////////////
version(Win64){
size_t[2] retVal;
asm pure nothrow @nogc
{
push RDI;
push RBX;
mov RDI, val;
mov RBX, 0;
mov RCX, 0;
mov RAX, 0;
mov RDX, 0;
lock; // lock always needed to make this op atomic
cmpxchg16b [RDI];
lea RDI, retVal;
mov [RDI], RAX;
mov 8[RDI], RDX;
pop RBX;
pop RDI;
}
return cast(typeof(return)) retVal;
}else{
asm pure nothrow @nogc
{
push RDI;
push RBX;
mov RBX, 0;
mov RCX, 0;
mov RAX, 0;
mov RDX, 0;
mov RDI, val;
lock; // lock always needed to make this op atomic
cmpxchg16b [RDI];
pop RBX;
pop RDI;
}
}
}
else
{
static assert( false, "Invalid template type specified." );
}
}
void atomicStore(MemoryOrder ms = MemoryOrder.seq, T, V1)( ref shared T val, V1 newval ) pure nothrow @nogc
if( __traits( compiles, { val = newval; } ) )
{
static if( T.sizeof == byte.sizeof )
{
//////////////////////////////////////////////////////////////////
// 1 Byte Store
//////////////////////////////////////////////////////////////////
static if( needsStoreBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov RAX, val;
mov DL, newval;
lock;
xchg [RAX], DL;
}
}
else
{
asm pure nothrow @nogc
{
mov RAX, val;
mov DL, newval;
mov [RAX], DL;
}
}
}
else static if( T.sizeof == short.sizeof )
{
//////////////////////////////////////////////////////////////////
// 2 Byte Store
//////////////////////////////////////////////////////////////////
static if( needsStoreBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov RAX, val;
mov DX, newval;
lock;
xchg [RAX], DX;
}
}
else
{
asm pure nothrow @nogc
{
mov RAX, val;
mov DX, newval;
mov [RAX], DX;
}
}
}
else static if( T.sizeof == int.sizeof )
{
//////////////////////////////////////////////////////////////////
// 4 Byte Store
//////////////////////////////////////////////////////////////////
static if( needsStoreBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov RAX, val;
mov EDX, newval;
lock;
xchg [RAX], EDX;
}
}
else
{
asm pure nothrow @nogc
{
mov RAX, val;
mov EDX, newval;
mov [RAX], EDX;
}
}
}
else static if( T.sizeof == long.sizeof && has64BitCAS )
{
//////////////////////////////////////////////////////////////////
// 8 Byte Store on a 64-Bit Processor
//////////////////////////////////////////////////////////////////
static if( needsStoreBarrier!(ms) )
{
asm pure nothrow @nogc
{
mov RAX, val;
mov RDX, newval;
lock;
xchg [RAX], RDX;
}
}
else
{
asm pure nothrow @nogc
{
mov RAX, val;
mov RDX, newval;
mov [RAX], RDX;
}
}
}
else static if( T.sizeof == long.sizeof*2 && has128BitCAS )
{
//////////////////////////////////////////////////////////////////
// 16 Byte Store on a 64-Bit Processor
//////////////////////////////////////////////////////////////////
version(Win64){
asm pure nothrow @nogc
{
push RDI;
push RBX;
mov R9, val;
mov R10, newval;
mov RDI, R10;
mov RBX, [RDI];
mov RCX, 8[RDI];
mov RDI, R9;
mov RAX, [RDI];
mov RDX, 8[RDI];
L1: lock; // lock always needed to make this op atomic
cmpxchg16b [RDI];
jne L1;
pop RBX;
pop RDI;
}
}else{
asm pure nothrow @nogc
{
push RDI;
push RBX;
lea RDI, newval;
mov RBX, [RDI];
mov RCX, 8[RDI];
mov RDI, val;
mov RAX, [RDI];
mov RDX, 8[RDI];
L1: lock; // lock always needed to make this op atomic
cmpxchg16b [RDI];
jne L1;
pop RBX;
pop RDI;
}
}
}
else
{
static assert( false, "Invalid template type specified." );
}
}
void atomicFence() nothrow @nogc
{
// SSE2 is always present in 64-bit x86 chips.
asm nothrow @nogc
{
naked;
mfence;
ret;
}
}
}
// This is an ABI adapter that works on all architectures. It type puns
// floats and doubles to ints and longs, atomically loads them, then puns
// them back. This is necessary so that they get returned in floating
// point instead of integer registers.
HeadUnshared!(T) atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)( ref const shared T val ) pure nothrow @nogc
if(__traits(isFloating, T))
{
static if(T.sizeof == int.sizeof)
{
static assert(is(T : float));
auto ptr = cast(const shared int*) &val;
auto asInt = atomicLoad!(ms)(*ptr);
return *(cast(typeof(return)*) &asInt);
}
else static if(T.sizeof == long.sizeof)
{
static assert(is(T : double));
auto ptr = cast(const shared long*) &val;
auto asLong = atomicLoad!(ms)(*ptr);
return *(cast(typeof(return)*) &asLong);
}
else
{
static assert(0, "Cannot atomically load 80-bit reals.");
}
}
////////////////////////////////////////////////////////////////////////////////
// Unit Tests
////////////////////////////////////////////////////////////////////////////////
version( unittest )
{
void testCAS(T)( T val ) pure nothrow
in
{
assert(val !is T.init);
}
body
{
T base;
shared(T) atom;
assert( base !is val, T.stringof );
assert( atom is base, T.stringof );
assert( cas( &atom, base, val ), T.stringof );
assert( atom is val, T.stringof );
assert( !cas( &atom, base, base ), T.stringof );
assert( atom is val, T.stringof );
}
void testLoadStore(MemoryOrder ms = MemoryOrder.seq, T)( T val = T.init + 1 ) pure nothrow
{
T base = cast(T) 0;
shared(T) atom = cast(T) 0;
assert( base !is val );
assert( atom is base );
atomicStore!(ms)( atom, val );
base = atomicLoad!(ms)( atom );
assert( base is val, T.stringof );
assert( atom is val );
}
void testType(T)( T val = T.init + 1 ) pure nothrow
{
testCAS!(T)( val );
testLoadStore!(MemoryOrder.seq, T)( val );
testLoadStore!(MemoryOrder.raw, T)( val );
}
//@@@BUG@@@ http://d.puremagic.com/issues/show_bug.cgi?id=8081
/+pure nothrow+/ unittest
{
testType!(bool)();
testType!(byte)();
testType!(ubyte)();
testType!(short)();
testType!(ushort)();
testType!(int)();
testType!(uint)();
testType!(shared int*)();
static class Klass {}
testCAS!(shared Klass)( new shared(Klass) );
testType!(float)(1.0f);
testType!(double)(1.0);
static if( has64BitCAS )
{
testType!(long)();
testType!(ulong)();
}
static if (has128BitCAS)
{
struct DoubleValue
{
long value1;
long value2;
}
align(16) shared DoubleValue a;
atomicStore(a, DoubleValue(1,2));
assert(a.value1 == 1 && a.value2 ==2);
while(!cas(&a, DoubleValue(1,2), DoubleValue(3,4))){}
assert(a.value1 == 3 && a.value2 ==4);
align(16) DoubleValue b = atomicLoad(a);
assert(b.value1 == 3 && b.value2 ==4);
}
version (D_LP64)
{
enum hasDWCAS = has128BitCAS;
}
else
{
enum hasDWCAS = has64BitCAS;
}
static if (hasDWCAS)
{
static struct List { size_t gen; List* next; }
shared(List) head;
assert(cas(&head, shared(List)(0, null), shared(List)(1, cast(List*)1)));
assert(head.gen == 1);
assert(cast(size_t)head.next == 1);
}
shared(size_t) i;
atomicOp!"+="( i, cast(size_t) 1 );
assert( i == 1 );
atomicOp!"-="( i, cast(size_t) 1 );
assert( i == 0 );
shared float f = 0;
atomicOp!"+="( f, 1 );
assert( f == 1 );
shared double d = 0;
atomicOp!"+="( d, 1 );
assert( d == 1 );
}
//@@@BUG@@@ http://d.puremagic.com/issues/show_bug.cgi?id=8081
/+pure nothrow+/ unittest
{
static struct S { int val; }
auto s = shared(S)(1);
shared(S*) ptr;
// head unshared
shared(S)* ifThis = null;
shared(S)* writeThis = &s;
assert(ptr is null);
assert(cas(&ptr, ifThis, writeThis));
assert(ptr is writeThis);
// head shared
shared(S*) ifThis2 = writeThis;
shared(S*) writeThis2 = null;
assert(cas(&ptr, ifThis2, writeThis2));
assert(ptr is null);
// head unshared target doesn't want atomic CAS
shared(S)* ptr2;
static assert(!__traits(compiles, cas(&ptr2, ifThis, writeThis)));
static assert(!__traits(compiles, cas(&ptr2, ifThis2, writeThis2)));
}
unittest
{
import core.thread;
// Use heap memory to ensure an optimizing
// compiler doesn't put things in registers.
uint* x = new uint();
bool* f = new bool();
uint* r = new uint();
auto thr = new Thread(()
{
while (!*f)
{
}
atomicFence();
*r = *x;
});
thr.start();
*x = 42;
atomicFence();
*f = true;
atomicFence();
thr.join();
assert(*r == 42);
}
// === atomicFetchAdd and atomicFetchSub operations ====
unittest
{
shared ubyte u8 = 1;
shared ushort u16 = 2;
shared uint u32 = 3;
shared byte i8 = 5;
shared short i16 = 6;
shared int i32 = 7;
assert(atomicOp!"+="(u8, 8) == 9);
assert(atomicOp!"+="(u16, 8) == 10);
assert(atomicOp!"+="(u32, 8) == 11);
assert(atomicOp!"+="(i8, 8) == 13);
assert(atomicOp!"+="(i16, 8) == 14);
assert(atomicOp!"+="(i32, 8) == 15);
version( AsmX86_64 )
{
shared ulong u64 = 4;
shared long i64 = 8;
assert(atomicOp!"+="(u64, 8) == 12);
assert(atomicOp!"+="(i64, 8) == 16);
}
}
unittest
{
shared ubyte u8 = 1;
shared ushort u16 = 2;
shared uint u32 = 3;
shared byte i8 = 5;
shared short i16 = 6;
shared int i32 = 7;
assert(atomicOp!"-="(u8, 1) == 0);
assert(atomicOp!"-="(u16, 1) == 1);
assert(atomicOp!"-="(u32, 1) == 2);
assert(atomicOp!"-="(i8, 1) == 4);
assert(atomicOp!"-="(i16, 1) == 5);
assert(atomicOp!"-="(i32, 1) == 6);
version( AsmX86_64 )
{
shared ulong u64 = 4;
shared long i64 = 8;
assert(atomicOp!"-="(u64, 1) == 3);
assert(atomicOp!"-="(i64, 1) == 7);
}
}
}
|
D
|
module UnrealScript.UTGame.UTRocketLight;
import ScriptClasses;
import UnrealScript.Helpers;
import UnrealScript.UDKBase.UDKExplosionLight;
extern(C++) interface UTRocketLight : UDKExplosionLight
{
public extern(D):
private static __gshared ScriptClass mStaticClass;
@property final static ScriptClass StaticClass() { mixin(MGSCC("Class UTGame.UTRocketLight")); }
private static __gshared UTRocketLight mDefaultProperties;
@property final static UTRocketLight DefaultProperties() { mixin(MGDPC("UTRocketLight", "UTRocketLight UTGame.Default__UTRocketLight")); }
}
|
D
|
/* swe_multidot.d, dotfield tuning paradigm.
*
* based on multidot.d for old render
- adjusted for rex7.8
- replaced old render commands with new ones
- created new functions to implement new render correctly
- led state list not used
- SWE 09.26.07
- VERSIONS:
v1:
v2:swe 12/ /2007; added option of blanks to the stimulus set
*
* based on dot.d, which had one 1s stimulus per trial
- adjusted for rex5 by Richard 3 April 1996
- minor bug fixes and 't e' support 6/25/96. KHB.
*
* created 2/23/98. HWH.
*
* this paradigm presents spiral space and linear dot-fields
* to measure direction tuning. The number of stimuli per
* trial, duration of stimuli, and the isi are all adjustable
* and are accessed from a submenu of the st menu. These parameters
* control the total duration of a trial. The number of each type
* of stimulus (linear or spiral space) is independently controlled
* in the st menu by the theta_min, theta_max, and theta_num parameters
* prefixed by l for linear or r for radial/rotary. The direction
* of each stimulus is calculated by theta_max-theta_min divided into
* equal steps (number of steps == theta_num.
*
*
* Secondary state list set control fixation monitoring LED added
* 4/03/98 HWH. Allows user control of fixation LED by setting
* a variable in the statelist (st menu) true. This variable, fix_led,
* is by default false (0); setting it to 1 turns on the monitoring.
* Note that to get this to work, a second step had to be added in
* the countdown; this results in needing to divide the duration counter
* by 2. This is done when the counter is reset for each trial, and is
* out of sight during running conditions.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include "ldev.h" /* hardware device defines */
#include "lcode.h" /* Ecodes */
#include "lcalib.h"
#include "pixels.h" /* pixel <==> degree conversion */
#include "make_msg.h" /* generates msgs, and provides all structs for commands.See /rexr3c/*.h */
#include "actions.h" /* action lib for render */
#include "ivunif.c" /*the random-number generator */
/* OLD COMMANDS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <i86.h>
#include "ldev.h" hardware device defines
#include "lcode.h" Ecodes
#include "calib.h" SGI stimulus display parameters
#include "render.h" defines for graphics objects
#include "locfunc.h" local, commonly used functions
#include "msg.h" messaging functions
#include "ivunif.c" the random-number generator */
#define MAXLIST 75 /* maximum number of stimuli possible:
this limits it to either 5 degree
steps for a single type (linear or spiral
space) or 10 degree steps if doing both */
#define OVR 75
/*
* codes for the status flag in the stimulus array
*/
#define READY 0
#define DONE 1
#define END 2
#define PIXSIZE 3
#define BLANK 3
#define FALSE 0
#define TRUE (~FALSE)
#define WIND0 0
#define EYEH_SIG 0
#define EYEV_SIG 1
#define PI 3.14159265
/* Ecodes */
#define MINIMUMCD 1025
#define TTEST 7777
/**********************************************************************
* Global variables.
**********************************************************************/
// Render Structures
DotStruct f_fpStruct; // fp parameters
static FF2DStruct f_ff2dStruct[(MAXLIST + 1)]; // ff2d parameters
int f_fpHandle = 0; // handle for dot
int f_ff2dHandle[MAXLIST + 1]; // handle for ff2d
int f_handleCount=0; // used in my_check_for_handles()
int f_i = 0;
// Render related variables
static int framerate = 85;
/* counters, flags, and seed declarations */
static int seedflg = 0;
static int nstim, /* number of stimuli configured */
stim_number,
stimcnt, /* counter for stimuli per trial */
durcnt, /* counter for duration */
isicnt, /* counter for isi */
errcnt, /* error count */
gtrcnt; /* good trial count */
static int alldone; /* through with this block! */
static long cseed = 0, pseed = 0; /* random seeds for flow field */
static int fpon = 0, dfon = 0; /* flags for fixation point & stimuli on */
static int window_on = 0; /* flag for fixation window on */
static int fix_led = 0; /* if 1, have fixation point LED on */
static int stimindex = 76;
/* set luminance and dot size */
static unsigned char dotsize = PIXSIZE, fg_grey, bg_grey;
/*now the stimulus structure:
a stimulus is either linear or spiral-space;
has a direction parameter theta;
and has a count of number of times completed */
struct stim {
int ind;
int handle;
int islinear;
int theta;
short stat;
int ngood;
};
/* stimulus array */
static struct stim stimlist[(MAXLIST+1)];
/* pointer for moving through stimulus array */
static struct stim *sp = NULL;
/* fixation point and dotfield handles */
static unsigned char fphandle,
dflhandle,
dfrhandle,
ffhandle;
static int fprh, ffrh; /* realization handles */
//extern Msg *msg;
/************************************************************************
* Declaration of statelist variables.
************************************************************************/
static long seed = 1111, /*day seed for random generator */
rtheta_ovr = NULLI, /*spiral space direction over-ride: if both on, default*/
ltheta_ovr = NULLI; /*linear direction over-ride */
static int
rtheta_min = 0,
rtheta_max = 315,
rtheta_num = 3, /* default is 45 degree steps */
ltheta_min = 0,
ltheta_max = 315,
ltheta_num = 3, /*default is 90 degree steps */
blnk_con = 1;
speed = 200,
fixx = 0,
fixy = 0,
fpsiz = 3, /* in tenths of degrees */
stimx = 0,
stimy = 0,
stimr = 100,
stimz = 280, /* in mm */
ptsiz = 2; /* pixel size of dots */
bar_R = 255, /* dot color */
bar_G = 255, /* dot color */
bar_B = 255, /* dot color */
coh = 750, /* in parts per 1000 */
stim_trial = 3, /*stimuli per trial */
nreps = 1000, /* trials per condition */
density = 60, /* hundred dots per cm*cm */
duration = 500, /*duration of stimulus in ms */
isi = 450, /* duration of inter-stimulus interval */
bg = 0;
remain;
/* TCP/IP info for render */
char local_addr[16] = "192.168.1.1";
char remote_addr[16]="192.168.1.2";
int remote_port = 2000;
/************************************************************************
*
* Control functions to make things happen.
*
************************************************************************/
/********************************* ecode ********************************
* Drops an ecode value to efile.
*/
int ecode(int icode)
{
EVENT ev;
int status=0;
if (icode < MINIMUMCD || icode > 8192)
{
dprintf("WARNING: ecode out of range %d\n", icode);
status = -1;
}
ev.e_code= (short int)icode;
ev.e_key= i_b->i_time;
ldevent(&ev);
return status;
}
/******************************** rinitf ********************************
*
* reinitializes lan connection on "reset states"
*/
void rinitf(void)
{
int status=0;
status = init_tcpip(local_addr, remote_addr, remote_port, 0);
}
/******************************** setbg() ********************************
*
* Sets background lumaniance
* swe 09/27/07
*
*/
int setbg()
{
render_bgcolor(bg, bg, bg);
return 0;
}
/************************ swe_check_for_handles() ***********************
*
* Checks for and recieves all handles for following trial
* swe 09.28.07
*
*/
int swe_check_for_handles()
{
int h=0;
int stimN = rtheta_num + ltheta_num + blnk_con;
while (render_check_for_handle(&h))
{
if (f_handleCount == 0)
{
f_fpHandle = h;
f_handleCount = 1;
dprintf("fp handle %d\n", f_fpHandle);
render_onoff(&h,HANDLE_OFF, ONOFF_NO_FRAME);
}
else if (f_handleCount >= 1 && f_handleCount <= stimN)
{
f_ff2dHandle[f_i] = h;
stimlist[f_i].handle = h;
dprintf("ff2d handle %d\n", f_ff2dHandle[f_i]);
render_onoff(&h, HANDLE_OFF, ONOFF_NO_FRAME);
f_handleCount++;
f_i++;
}
else
{
f_ff2dHandle[OVR] = h;
stimlist[OVR].handle = h;
f_handleCount++;
dprintf("Override Handle %d\n", f_ff2dHandle[OVR]);
render_onoff(&h, HANDLE_OFF, ONOFF_NO_FRAME);
}
}
return(f_handleCount >= (stimN+2));
}
/********************** swe_check_for_went *********************************/
int swe_check_for_went()
{
int frames = 0;
int wstatus;
wstatus = render_check_for_went(&frames);
if (wstatus < 0)
{
// ERROR! not clear what to do ...
dprintf("ERROR in render_check_for_went!\n");
}
else if (wstatus == 1)
{
// dprintf("%d\n", frames); * for checking timing with frames *
}
return wstatus;
}
/********************************* my_conf_all() *************************
*
* configures all flow fields for next trial and configures fp
* swe 09.27.07
*
*/
int my_conf_all()
{
int i;
conf_fp(&f_fpStruct); // configure and render fp
render_dot(&f_fpStruct);
// configure and render stim on sitmlist
for (i = 0; stimlist[i].stat != END; i++)
{
conf_ff2d(&f_ff2dStruct[i],i);
render_ff2d(&f_ff2dStruct[i]);
}
// configure and render override stim
conf_ff2d(&f_ff2dStruct[OVR],OVR);
render_ff2d(&f_ff2dStruct[OVR]);
return 0;
}
/********************************* conf_fp() *****************************
*
* configures the fixation point
*
* 9/27/07 swe
* changed to make configure the fixation point (size, location, color, etc)
*
*/
int conf_fp(DotStruct *pdot)
{
// set dot parameters. Note color is hard-coded!
int siz;
float fx = to_pixels((float)fixx/10);
float fy = to_pixels((float)fixy/10);
siz = to_pixels((float)fpsiz/10);
pdot->xorigin = fx;
pdot->yorigin = fy;
pdot->xsize = siz;
pdot->ysize = siz;
pdot->depth = 10;
pdot->r = 255;
pdot->g = 0;
pdot->b = 0;
pdot->a = 0;
//vsend(MSG_CFGPT, "bbbbb", CIRCLE, 8, 255, bg_grey, bg_grey); OLD FUNCTION
return 0;
}
/***************************** get_fphandle() *****************************
*
* gets the handle for the fixation point
*
int get_fphandle(void)
{
if ((fphandle=gethandle())==-1)
{
rxerr("get_fphandle(): invalid message: expecting handle");
return ERRORCD;
}
return 0;
}
*/
/****************************** fpask() *******************************
*
* requests that a FP be displayed
*/
int fpask(void)
{
/* swe 09/28/07
* new render commands */
render_update(f_fpHandle, &f_fpStruct, sizeof(DotStruct), HANDLE_ON);
render_frame(0);
fpon = 1;
/* OLD COMMANDS
vsend(MSG_SHOW, "bbllll", fphandle, 0,
xpix(fixx, stimz),
ypix(fixy, stimz),
0,0);
fprh = gethandle();
send(MSG_FRAME);
fpon = 1;
*/
return 0;
}
/**************************** fpoff() ************************************
*
* turns off fixation point
*/
static int fpoff(void)
{
if (fpon)
{
/* swe 09.28.07
* new render commands */
render_onoff(&f_fpHandle, HANDLE_OFF, ONOFF_NO_FRAME);
render_frame(1);
fpon = 0;
ecode(FPOFFCD);
/* OLD COMMANDS
vsend(MSG_UNSHOW, "bb", fphandle, fprh);
send(MSG_FRAME);
getmsg();
fpon = 0;
*/
}
return 0;
}
/***************************** stimoff() *********************************
*
* turns off the fixation point and the dot fields if they're on.
*/
static int stimoff(int flag)
{
if (rtheta_ovr != NULLI || ltheta_ovr != NULLI)
{
render_onoff(&f_ff2dHandle[OVR], HANDLE_OFF, ONOFF_NO_FRAME);
render_frame(1);
}
else
{
render_onoff(&f_ff2dHandle[stimindex], HANDLE_OFF, ONOFF_NO_FRAME);
render_frame(1);
/* OLD COMMANDS
vsend(MSG_UNSHOW, "bb", ffhandle, ffrh);
send(MSG_FRAME);
getmsg();
dfon = 0;
*/
}
if (flag)
{
sp->stat = DONE;
sp->ngood++;
stimcnt --;
}
return 0;
}
/****************************** initial() *******************************
*
* initializes the stimulus array
*/
static int initial(void)
{
int i;
int ndx = 0; /* stimulus array index */
int theta; /* direction parameter for stimulus array configuration*/
// Set f_handleCount and f_i to zero after reset states
f_handleCount = 0;
f_i = 0;
// Initialize "to_pixels();
initialize_pixel_conversion(x_dimension_mm, y_dimension_mm, x_resolution, y_resolution, stimz); // Initializes to_pixels function properties
/* initialize counters */
errcnt = 0;
gtrcnt = 0;
stimcnt = stim_trial;
/* free up any old handles lying around
send(MSG_FREE); */
/*initialize random generator with today's seed*/
if (!seedflg)
{
ivunif(seed, 0);
seedflg++;
}
/* Generate the running array of stimuli. */
stim_number = rtheta_num + ltheta_num + blnk_con;
if ((nstim = rtheta_num + ltheta_num) >= MAXLIST)
{
rxerr("initial(): too many stimuli in array");
return 0;
}
for (i = 0, theta = rtheta_min; i < rtheta_num; i++, ndx++)
{
stimlist[ndx].ind = ndx;
stimlist[ndx].islinear = 0;
stimlist[ndx].theta = theta;
stimlist[ndx].stat = READY;
stimlist[ndx].ngood = 0;
theta += (rtheta_max - rtheta_min)/(rtheta_num - 1);
}
for (i = 0, theta = ltheta_min; i < ltheta_num; i++, ndx++)
{
stimlist[ndx].ind = ndx;
stimlist[ndx].islinear = 1;
stimlist[ndx].theta = theta;
stimlist[ndx].stat = READY;
stimlist[ndx].ngood = 0;
theta += (ltheta_max - ltheta_min)/(ltheta_num - 1);
}
stimlist[ndx].ind = ndx;
stimlist[ndx].islinear = BLANK;
stimlist[ndx].theta = 0;
stimlist[ndx].stat = READY;
stimlist[ndx].ngood = 0;
stimlist[(ndx+1)].stat = END;
// Generate override stimlist
stimlist[OVR].ind = OVR;
stimlist[OVR].islinear = 1;
stimlist[OVR].theta = theta;
stimlist[OVR].stat = OVR;
stimlist[OVR].ngood = 0;
/* set up number of trials necessary to complete
* repetitions of all stimuli given the specified number of stimuli
* per trial as given in the st menu. If the number of stimuli
* is not evenly divisible by the number of stimuli per trial,
* an extra trial is required, and some stimuli may be presented
* an extra time to complete that trial */
remain = (nreps * nstim) / stimcnt;
if ((nstim % stimcnt) != 0) remain++;
return 0;
}
/***************************** newtrial() ********************************
*
* resets the counters for stimuli per trial, duration, and isi
* also reseeds random dot fields, and configures the dotfields
* with those seeds
*/
int newtrial(void)
{
conf_fp(&f_fpStruct); /*fixation point configuration because handle freed*/
getseeds(); /* get pseed and cseed for this trial */
//conf_ff2d(&f_ff2dStruct[stimindex],stimindex); * use this trial's seeds and configure both dot fields *
stimcnt = stim_trial; /*initialize stimulus count parameter*/
return 0;
}
/***************************** getseeds() ********************************
*
* gets the random seeds for this trial
* called by newtrial()
*/
int getseeds(void)
{
pseed = (long)ivunif(0, 1000);
cseed = (long)ivunif(0, 1000);
//printf("p = %d\tc= %d\n",pseed,cseed);
return 0;
}
/***************************** conf_ff2d() *********************************
*
*
* swe 9/26/07
* now used to configure any flow field by filling struct called by function
* similar to get_ff2d_params in "dotmap.d"
*
*/
// New Commands
void conf_ff2d(FF2DStruct* pff2d,int i)
{
int npoints;
int dc_R;
int dc_G;
int dc_B;
float degperframe = (float)speed/10/framerate;
float area = 1.0;
float rad = to_pixels((float)stimr/10);
float den = (float)density/100;
float sx = to_pixels((float)stimx/10);
float sy = to_pixels((float)stimy/10);
if (stimlist[i].islinear == BLANK)
{
dc_R = 0;
dc_G = 0;
dc_B = 0;
}
else
{
dc_R = bar_R;
dc_G = bar_G;
dc_B = bar_B;
}
/*
if (i == 0)
{
bar_R = 255;
bar_G = 0;
bar_B = 0;
}
else if (i == 1)
{
bar_R = 0;
bar_G = 255;
bar_B = 255;
}
else if (i == 2)
{
bar_R = 0;
bar_G = 0;
bar_B = 255;
}
else
{
bar_R = 255;
bar_G = 255;
bar_B = 255;
}
*/
area = PI*stimr*stimr/100;
npoints = (int)(den*area);
pff2d->linear = stimlist[i].islinear;
pff2d->npts = npoints;
pff2d->prob = (float)coh/1000;
pff2d->radius = rad;
pff2d->pseed = pseed;
pff2d->cseed = cseed;
pff2d->pixsz = ptsiz;
pff2d->depth = 20; // TODO: NO HARDCODING
pff2d->v = to_pixels(degperframe);
//pff2d->dx = 0;
//pff2d->dy = 0;
pff2d->x = sx;
pff2d->y = sy;
pff2d->width = 0; // TODO: NOT IMPLEMENTED
pff2d->angle = stimlist[i].theta;
pff2d->r = dc_R;
pff2d->g = dc_G;
pff2d->b = dc_B;
//dprintf("stimr = %d %d\n",stimr,(int)(100*rad));
}
/***************************** conf_ff() *********************************
*
* OLD FUNCTION
* replaced by conf_ff2d(), functionallity changed considerably swe 09.28.07
* configures the dot fields for this trial using the seeds
* retrieved by getseeds()
* called by newtrial()
*
*
int conf_ff(void)
{
long npoints;
float rcm;
long rpix = (long)(stimz * SINE_1DEG * XRES/XDIM) * (stimr * 0.1) + 0.5;
const float pi = acos(-1);
rcm = (XDIM/XRES) * rpix;
npoints = (long) ((density/100.0) * (pi * rcm * rcm) );
#if 0
if (dflhandle > 0){
dflhandle = 0;
}
if (dfrhandle > 0){
dfrhandle = 0;
}
#endif
vsend(MSG_CFG2DFFL, "lllllbbbb",
npoints,
coherence,
rpix,
pseed,
cseed,
dotsize,
fg_grey,
fg_grey,
fg_grey);
dflhandle = gethandle();
vsend(MSG_CFG2DFFR, "lllllbbbb",
npoints,
coherence,
rpix,
pseed,
cseed,
dotsize,
fg_grey,
fg_grey,
fg_grey);
dfrhandle = gethandle();
return 0;
}
*/
/****************************** next_dotf() *******************************
*
* requests next dotfield within trial
* resets the duration and isi counters as well
*/
static int next_dotf(void)
{
/* OLD COMMANDS:
* calculate stimulus position in pixels
long xpos = xpix(stimx, stimz);
long ypos = ypix(stimy, stimz);*/
/* OLD COMMANDS: get degrees per second (speed)*/
//long dps = (long) (1000.0 *(stimz * speed/10.0) * SINE_1DEG * XRES/XDIM);
long width = 0; /* width of directions * 100 */
/* reset counters for duration and isi;
must happen for each stim
divide by 2 because of the extra step necessary
in the state list for the auxiliary
(fix_led control) state set to work */
durcnt = framerate*duration/1000; /* number of frames for each stimulus */
isicnt = framerate*isi/1000; /* number of frames for each isi */
if (ltheta_ovr != NULLI && rtheta_ovr !=NULLI)
rxerr("next_dotf(): WARNING, both overrides set, using rtheta");
if (rtheta_ovr != NULLI || ltheta_ovr != NULLI)
{
if (rtheta_ovr != NULLI)
{
stimlist[OVR].theta = rtheta_ovr * 100;
stimlist[OVR].islinear = 0;
conf_ff2d(&f_ff2dStruct[OVR],OVR);
render_update(f_ff2dHandle[OVR], &f_ff2dStruct[OVR], sizeof(FF2DStruct), HANDLE_ON);
/* OLD COMMANDS
vsend(MSG_SHOW, "bblllll",
dfrhandle,
0,
dps,
(rtheta_ovr * 100),
width,
xpos,
ypos);
ffhandle = dfrhandle;
*/
}
else if (ltheta_ovr != NULLI)
{
stimlist[OVR].theta = ltheta_ovr * 100;
stimlist[OVR].islinear = 1;
conf_ff2d(&f_ff2dStruct[OVR],OVR);
render_update(f_ff2dHandle[OVR], &f_ff2dStruct[OVR], sizeof(FF2DStruct), HANDLE_ON);
/* OLD COMMANDS
vsend(MSG_SHOW, "bblllll",
dflhandle,
0,
dps,
(ltheta_ovr * 100),
width,
xpos,
ypos);
ffhandle = dflhandle;
*/
}
}
else
{
//dprintf("nextdot= %d\t%d\n",stimindex,f_ff2dHandle[stimindex]);
conf_ff2d(&f_ff2dStruct[stimindex],stimindex);
render_update(f_ff2dHandle[stimindex], &f_ff2dStruct[stimindex], sizeof(FF2DStruct), HANDLE_ON);
/* OLD COMMANDS
if (sp->islinear)
{
vsend(MSG_SHOW, "bblllll",
dflhandle,
0,
dps,
(long)(sp->theta * 100),
width,
xpos,
ypos);
ffhandle = dflhandle;
}
else
{
vsend(MSG_SHOW, "bblllll",
dfrhandle,
0,
dps,
(long)(sp->theta * 100),
width,
xpos,
ypos);
ffhandle = dfrhandle;
}*/
}
/*turn on the stimulus on flag */
dfon = 1;
/*send the frame to synchronize*/
render_frame(0);
ecode(TTEST);
return 0;
}
/****************************** next_stim() *******************************
*
* figures out the next stimulus type in the sequence
*/
static int next_stim(void)
{
int index, rindx,
active = 0;
stimindex = OVR;
/* figure out number of active entries */
for (sp = &stimlist[0]; sp->stat != END; sp++)
if (sp->stat == READY) active++;
/* reset all if this "block" complete */
if (!active)
{
for(sp = &stimlist[0]; sp->stat != END; sp++)
sp->stat = READY;
active = nstim;
}
/* get random number for this presentation */
rindx = ivunif(0, active - 1); /* shouldn't be here if counter=nstim */
/* now skip down into list by this amount */
sp = stimlist;
while (sp->stat != READY) sp++; /* start pointing at the first live one */
while (1)
{
while (sp->stat == DONE) sp++;
if (rindx <= 0) break;
sp++;
rindx--;
}
/* now do the calculations necessary to provice a unique ECODE
* to identify this stimulus. The method here is exactly as used
* in the original dot tuning paradigm. The index number is simply
* the number of the stimulus in the stimulus array, which is zero-
* based. That index is then added to 3500 for spiral space stimuli
* and to 3000 for linear stimuli.
*/
index = (sp - &stimlist[0]);
stimindex = sp->ind;
if (sp->islinear)
{
return 3000 + index;
}
else
{
return 3500 + index;
}
}
/****************************** winon() **********************************
*
* opens fixation window (calls a bunch of library functions from REX to
* do so)
*/
static int winon(long xsiz, long ysiz)
{
wd_src_pos(WIND0, WD_DIRPOS, 0, WD_DIRPOS, 0);
wd_pos(WIND0, (long)fixx, (long)fixy);
wd_siz(WIND0, (long)xsiz, (long)ysiz);
wd_cntrl(WIND0, WD_ON);
wd_src_check(WIND0,WD_SIGNAL, EYEH_SIG, WD_SIGNAL, EYEV_SIG);
return 0;
}
/******************************wincheck() *******************************
*
* checks if fixation window on (window_on = 1) for LED control
*/
int wincheck()
{
window_on = 1;
return 0;
}
/***************************** alloff() **********************************
*
* closes up shop
*/
static int alloff(void)
{
wd_cntrl(WIND0, WD_OFF); /*this turns off the fixation window */
fpoff(); /*this turns off the fixation point */
window_on = 0;
stimoff(0); /*this turns off any stimuli on without marking them done */
/*send(MSG_FREE); clear all configured handles*/
alldone = 0;
return 0;
}
/**************************** trlcount() *********************************
*
* scores the trial correct or incorrect; counts down number of trials
*/
static int trlcount(int flag)
{
score(flag); /* if TRUE, REX wants to know about the reward */
if (flag) remain --; /* if TRUE, the trial's complete so count it */
return 0;
}
/***************************** killslave() ********************************
*
* sends MSG_DONE on nonzero argument
*
static int killslave(int flag)
{
if (flag) send(MSG_DONE);
return(flag);
}
*/
/************************************************************************
* Ecode-returning functions for data recording.
* These are called by states in the state set. The order in which these
* are called is the key to interpreting the header info.
* Each ECODE here is defined as HEADBASE (which is defined as 1500)
* + the value of the variable.
************************************************************************/
int fpxcd(void) {return(HEADBASE + fixx);}
int fpycd(void) {return(HEADBASE + fixy);}
int stxcd(void) {return(HEADBASE + stimx);}
int stycd(void) {return(HEADBASE + stimy);}
int strcd(void) {return(HEADBASE + stimr);}
int stzcd(void) {return(HEADBASE + stimz);}
int rtmincd(void) {return(HEADBASE + rtheta_min);}
int rtmaxcd(void) {return(HEADBASE + rtheta_max);}
int rtnumcd(void) {return(HEADBASE + rtheta_num);}
int ltmincd(void) {return(HEADBASE + ltheta_min);}
int ltmaxcd(void) {return(HEADBASE + ltheta_max);}
int ltnumcd(void) {return(HEADBASE + ltheta_num);}
int spdcd(void) {return(HEADBASE + speed);}
int nptcd(void) {return(HEADBASE + density);}
int ptszcd(void) {return(HEADBASE + dotsize);}
int cohcd(void) {return(HEADBASE + coh);}
int fgcd(void) {return(HEADBASE + fg_grey);}
int bgcd(void) {return(HEADBASE + bg_grey);}
int numcd(void) {return(HEADBASE + stim_trial);}
int durcd(void) {return(HEADBASE + duration);}
int isicd(void) {return(HEADBASE + isi);}
/*************************************************************************
* The next are used on the fly.
*************************************************************************/
static int ovrcd(void)
{
/* if either over-ride is set, drop an ECODE to note that */
if (rtheta_ovr != NULLI || ltheta_ovr != NULLI)
return OVRDCD;
else return 0; /*if neither over-ride is set, don't need an ECODE */
}
/*************************** pr_info *************************************
*
* prints book-keeping information
*/
static void pr_info(void)
{
int i;
//OLD BUFFER COMMANDS REMOVED by swe 10.01.07
//extern char outbuf[];
//setbuf(stdout, &outbuf);
/* print out the header information: here
* index #, linear or no, dir, status, and number done
*/
printf("index\tlin?\ttheta\tstat\tcount\thandle\n");
/* for each stimulus, loop through and print out the
* above information
*/
for(i = 0; stimlist[i].stat != END; i++)
{
printf("%2d\t%1d\t%3d\t%1d\t%2d\t%3d\n",
stimlist[i].ind,
stimlist[i].islinear,
stimlist[i].theta,
stimlist[i].stat,
stimlist[i].ngood,
stimlist[i].handle);
}
printf("\n");
/* calculate the number of trials done, and then print out
* number of trials done followed by number of errors */
printf("%d trials, %d errors\n", (nstim * nreps)/stim_trial - remain, errcnt);
/* clear out the buffers */
//fflush(stdout);
//setbuf(stdout, 0);
}
/**************************** n_exlist() **********************************
*
* enables 't e' requests to print bookeeping info
*
void n_exlist(char *vstr)
{
switch(*vstr)
{
case 't': type a list
pr_info();
break;
default:
badverb(); this is REX error message call
break;
}
}*/
/************************************************************************
* Ecode-returning functions for data recording. The order in which these
* are called is the key to interpreting the header info.
************************************************************************/
/* the following constructs a secondary statelist which
* is called as a submenu from the st menu; the items
* included in this submenu pertain to stimulus attributes
* that are somewhat less likely to be adjusted under normal
* running conditions. Note that the first three parameters
* here (stimulus duration, isi, and number of stimuli per
* trial) are adjustable and together control the duration
* of a single trial.
*/
VLIST stim_vl[] = {
"duration", &duration, NP, NP, 0, ME_DEC,
"isi", &isi, NP, NP, 0, ME_DEC,
"stim/trial", &stim_trial, NP, NP, 0, ME_DEC,
"coherence", &coh, NP, NP, 0, ME_DEC,
"density", &density, NP, NP, 0, ME_DEC,
"stim_R", &bar_R, NP, NP, 0, ME_DEC,
"stim_G", &bar_G, NP, NP, 0, ME_DEC,
"stim_B", &bar_B, NP, NP, 0, ME_DEC,
NS
};
/* the following function takes the secondary statelist as
* defined above and returns a menu; this allows it to be
* included in your primary statelist (the st menu) as
* a submenu. Note that VLIST and MENU are return types
* specified deep in the bowels of REX. */
MENU stim_me =
{
"stim_params", &stim_vl, NP, NP, 0, NP, NS,
};
char hm_stim[] = "";
/* now the primary statelist, as usually defined. For the
* st menu to work, this MUST be called state_vl[]. In
* this particular statelist (for this paradigm!) the
* inclusion of the stimulus parameter submenu occurs as
* the last item of the statelist; look there to see
* how to include a submenu. The order is not essential;
* you may include multiple submenus within a statelist,
* and they don't have to be the last items.
*/
VLIST state_vl[] = {
"day_seed", &seed, NP, NP, 0, ME_DEC,
"fp_x", &fixx, NP, NP, 0, ME_DEC,
"fp_y", &fixy, NP, NP, 0, ME_DEC,
"fp_size", &fpsiz, NP, NP, 0, ME_DEC,
"stim_x", &stimx, NP, NP, 0, ME_DEC,
"stim_y", &stimy, NP, NP, 0, ME_DEC,
"stim_r", &stimr, NP, NP, 0, ME_DEC,
"point_size", &ptsiz, NP, NP, 0, ME_DEC,
"CRT_dist(cm)", &stimz, NP, NP, 0, ME_DEC,
"rtheta_min", &rtheta_min, NP, NP, 0, ME_DEC,
"rtheta_max", &rtheta_max, NP, NP, 0, ME_DEC,
"rtheta_num", &rtheta_num, NP, NP, 0, ME_DEC,
"rtheta_override", &rtheta_ovr, NP, NP, 0, ME_NVALD,
"ltheta_min", <heta_min, NP, NP, 0, ME_DEC,
"ltheta_max", <heta_max, NP, NP, 0, ME_DEC,
"ltheta_num", <heta_num, NP, NP, 0, ME_DEC,
"ltheta_override", <heta_ovr, NP, NP, 0, ME_NVALD,
"speed", &speed, NP, NP, 0, ME_DEC,
"trials", &nreps, NP, NP, 0, ME_DEC,
"fix_led", &fix_led, NP, NP, 0, ME_DEC,
NS,
};
/*
* Help message.
*/
char hm_sv_vl[] = "";
MENU umenus[] = {
{"state_vars", &state_vl, NP, NP, 0, NP, hm_sv_vl},
{"separator", NP},
{"stim_params", &stim_vl, NP, NP, 0, NP, hm_stim},
{NS},
};
/*
* User-supplied noun table.
*/
NOUN unouns[] = {
"",
};
/*
* User-supplied function table.
*/
USER_FUNC ufuncs[] = {
{"print_info", &pr_info, "%d"},
{""},
};
%%
id 121 /*unique paradigm identifier*/
restart rinitf
main_set {
status ON
begin first:
code STARTCD
rl 0
to sendping
sendping:
rl 5
do render_send_ping()
to waitping
waitping:
rl 10
time 100
to checkping
checkping:
rl 15
to reset on 1 % render_check_for_ping
to pauseping
pauseping:
rl 20
time 1000
to sendping
reset:
rl 25
do render_reset()
to pause1
pause1:
rl 20
to pause2 on +PSTOP & softswitch
to setbg on -PSTOP & softswitch
pause2:
code PAUSECD
rl 30
to setbg on -PSTOP & softswitch
setbg:
do setbg()
rl 50
to setup
setup:
time 1000
do initial()
to myconfall
myconfall:
do my_conf_all()
to headcd on 1 % swe_check_for_handles
headcd:
code HEADCD
to fpxcd
fpxcd:
do fpxcd()
to fpycd
fpycd:
do fpycd()
to stxcd
stxcd:
do stxcd()
to stycd
stycd:
do stycd()
to strcd
strcd:
do strcd()
to stzcd
stzcd:
do stzcd()
to rtmincd
rtmincd:
do rtmincd()
to rtmaxcd
rtmaxcd:
do rtmaxcd()
to rtnumcd
rtnumcd:
do rtnumcd()
to ltmincd
ltmincd:
do ltmincd()
to ltmaxcd
ltmaxcd:
do ltmaxcd()
to ltnumcd
ltnumcd:
do ltnumcd()
to spdcd
spdcd:
do spdcd()
to nptcd
nptcd:
do nptcd()
to ptszcd
ptszcd:
do ptszcd()
to cohcd
cohcd:
do cohcd()
to fgcd
fgcd:
do fgcd()
to bgcd
bgcd:
do bgcd()
to numcd
numcd:
do numcd()
to durcd
durcd:
do durcd()
to isicd
isicd:
do isicd()
to loop
loop:
time 10
rl 70
to pause3
pause3:
to pause4 on +PSTOP & softswitch
to next on -PSTOP & softswitch
pause4:
code PAUSECD
to next on -PSTOP & softswitch
next:
do newtrial()
time 10
to ovrcd
ovrcd:
do ovrcd()
to iti
iti:
time 1500 /* rest of the ISI */
to fpon
fpon:
code FIXASK
do fpask()
to winon on 1 % swe_check_for_went
winon:
code FPONCD
time 20
do winon(20,20)
to grace
grace:
time 3000
to fixtim on -WD0_XY & eyeflag
to off
off:
do alloff()
to loop
fixtim:
code FIXCD
time 250
rl 20
do wincheck()
to noise on +WD0_XY & eyeflag /*don't punish for brkfix*/
to trstart
noise:
do alloff()
to loop
trstart:
code TRLSTART
to stimloop
stimloop:
do next_stim() /* choose the next stimulus */
to stim
stim:
do next_dotf() /* send the show messages */
to check on 1 % swe_check_for_went
check:
to punish on +WD0_XY & eyeflag
to went
went:
code STIMON
rl 60
to delay
delay:
to punish on +WD0_XY & eyeflag
to stimdone on 0 ? durcnt
to delay2
delay2:
do render_frame(0)
to delay on 1 % swe_check_for_went
stimdone:
code STIMOFF
do stimoff(1)
rl 30
to isi
isi:
to punish on +WD0_XY & eyeflag
to stimcount on 0 ? isicnt
to isi2
isi2:
do render_frame(0)
to punish on +WD0_XY & eyeflag
to isi on 1 % swe_check_for_went
stimcount:
to good on -TRUE & stimcnt
to stimloop
good:
code FPOFFCD
do fpoff()
rl 10
to reward
reward:
code REWCD
do dio_on(REW)
time 50
to rewoff
rewoff:
do dio_off(REW)
to score
score:
do trlcount(1)
to trlend
punish:
code BREAKFIXCD
do alloff()
rl 10
to beep
beep:
do dio_on(BEEP)
time 100
to bpoff
bpoff:
do dio_off(BEEP)
to timout
timout:
do trlcount(0)
time 1000
to trlend
/*qryerr:
do qryerr()
to trlend*/
trlend:
do alloff()
to blkdone on -TRUE & remain
to loop
blkdone:
rl 0
to loop on +TRUE & remain
exit:
/* do killslave(0)*/
to loop
abort list:
trlend blkdone exit
}
/*
%%
id 121 unique paradigm identifier
restart rinitf
main_set {
status ON
begin first:
code STARTCD
rl 0
to pause1
pause1:
to pause2 on +PSTOP & drinput
to setbg on -PSTOP & drinput
pause2:
code PAUSECD
to setbg on -PSTOP & drinput
setbg:
do setbg()
to setup
setup:
time 1000
do initial()
to headcd
headcd:
code HEADCD
to fpxcd
fpxcd:
do fpxcd()
to fpycd
fpycd:
do fpycd()
to stxcd
stxcd:
do stxcd()
to stycd
stycd:
do stycd()
to strcd
strcd:
do strcd()
to stzcd
stzcd:
do stzcd()
to rtmincd
rtmincd:
do rtmincd()
to rtmaxcd
rtmaxcd:
do rtmaxcd()
to rtnumcd
rtnumcd:
do rtnumcd()
to ltmincd
ltmincd:
do ltmincd()
to ltmaxcd
ltmaxcd:
do ltmaxcd()
to ltnumcd
ltnumcd:
do ltnumcd()
to spdcd
spdcd:
do spdcd()
to nptcd
nptcd:
do nptcd()
to ptszcd
ptszcd:
do ptszcd()
to cohcd
cohcd:
do cohcd()
to fgcd
fgcd:
do fgcd()
to bgcd
bgcd:
do bgcd()
to numcd
numcd:
do numcd()
to durcd
durcd:
do durcd()
to isicd
isicd:
do isicd()
to loop
loop:
time 10
to pause3
pause3:
to pause4 on +PSTOP & drinput
to next on -PSTOP & drinput
pause4:
code PAUSECD
to next on -PSTOP & drinput
next:
do newtrial()
time 10
to ovrcd
ovrcd:
do ovrcd()
to iti
iti:
time 1500 rest of the ISI
to fpon
fpon:
code FIXASK
do fpask()
to winon
winon:
code FPONCD
time 20
do winon(10,10)
to grace
grace:
time 3000
to fixtim on -WD0_XY & eyeflag
to off
off:
do alloff()
to loop
fixtim:
time 250
rl 20
do wincheck()
to noise on +WD0_XY & eyeflag don't punish for brkfix
to trstart
noise:
do alloff()
to loop
trstart:
code TRLSTART
to stimloop
stimloop:
do next_stim() choose the next stimulus
to stim
stim:
do next_dotf() send the show messages
to wait1
wait1:
to check on 1 % msg_pending
check:
chkstim()
to punish on +WD0_XY & eyeflag
to went
went:
code STIMON
rl 60
to delay
delay:
to punish on +WD0_XY & eyeflag
to stimdone on 0 ? durcnt
to delay2
delay2:
to delay avoids complete recursion
stimdone:
code STIMOFF
do stimoff(1)
rl 30
to isi
isi:
to punish on +WD0_XY & eyeflag
to stimcount on 0 ? isicnt
to isi2
isi2:
to punish on +WD0_XY & eyeflag
to isi avoids complete recursion
stimcount:
to good on -TRUE & stimcnt
to stimloop
good:
code FPOFFCD
do fpoff()
rl 10
to reward
reward:
code REWCD
do dio_on(REW)
time 50
to rewoff
rewoff:
do dio_off(REW)
to score
score:
do trlcount(1)
to trlend
punish:
code BREAKFIXCD
do alloff()
rl 10
to beep
beep:
do dio_on(BEEP)
time 100
to bpoff
bpoff:
do dio_off(BEEP)
to timout
timout:
do trlcount(0)
time 1000
to qryerr
qryerr:
do qryerr()
to trlend
trlend:
do alloff()
to blkdone on -TRUE & remain
to loop
blkdone:
rl 0
to loop on +TRUE & remain
exit:
do killslave(0)
to loop
abort list:
trlend blkdone exit
}
*/
/* now for the fixation LED control state set; this controls the
fixation monitoring LED. To turn on monitoring, select fix_led
in the st menu and set it equal to 1. To turn it off, select
fix_led and set it to 0 (false). This turns on an LED whenever
the critter's fixating; turns off the LED whenever the eye's not
in the window.
DISABLED 6/4/98 for debugging. KHB.
fix_set {
status ON
begin isledon:
to led_off on 1 = fix_led
led_on:
do dio_on(FIX_LED)
to led_off on 0 = window_on
led_off:
do dio_off(FIX_LED)
to led_on on 1 = window_on
}
*/
|
D
|
/*
[The "BSD licence"]
Copyright (c) 2005-2008 Terence Parr
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
module antlr.runtime.misc.Stats;
import tango.io.FilePath;
import tango.io.device.File;
import tango.math.Math;
import tango.sys.Environment;
/** Stats routines needed by profiler etc...
// note that these routines return 0.0 if no values exist in the X[]
// which is not "correct", but it is useful so I don't generate NaN
// in my output
*/
public class Stats {
public const char[] ANTLRWORKS_DIR = "antlrworks";
/** Compute the sample (unbiased estimator) standard deviation following:
*
* Computing Deviations: Standard Accuracy
* Tony F. Chan and John Gregg Lewis
* Stanford University
* Communications of ACM September 1979 of Volume 22 the ACM Number 9
*
* The "two-pass" method from the paper; supposed to have better
* numerical properties than the textbook summation/sqrt. To me
* this looks like the textbook method, but I ain't no numerical
* methods guy.
*/
public static double stddev(int[] X) {
auto m = X.length;
if ( m<=1 ) {
return 0;
}
double xbar = avg(X);
double s2 = 0.0;
for (int i=0; i<m; i++){
s2 += (X[i] - xbar)*(X[i] - xbar);
}
s2 = s2/(m-1);
return sqrt(s2);
}
/** Compute the sample mean */
public static double avg(int[] X) {
double xbar = 0.0;
auto m = X.length;
if ( m==0 ) {
return 0;
}
for (int i=0; i<m; i++){
xbar += X[i];
}
if ( xbar>=0.0 ) {
return xbar / m;
}
return 0.0;
}
public static int min(int[] X) {
int min = int.max;
auto m = X.length;
if ( m==0 ) {
return 0;
}
for (int i=0; i<m; i++){
if ( X[i] < min ) {
min = X[i];
}
}
return min;
}
public static int max(int[] X) {
int max = int.min;
auto m = X.length;
if ( m==0 ) {
return 0;
}
for (int i=0; i<m; i++){
if ( X[i] > max ) {
max = X[i];
}
}
return max;
}
public static int sum(int[] X) {
int s = 0;
auto m = X.length;
if ( m==0 ) {
return 0;
}
for (int i=0; i<m; i++){
s += X[i];
}
return s;
}
public static void writeReport(char[] filename, char[] data) {
// auto filepath=FilePath(filename);
// auto parent=filepath.parent;
// auto absoluteFilename = FilePath(filename).path;
// auto f = new FileConduit(absoluteFilename);
// File parent = f.getP28arentFile();
// parent.mkdirs();
// filepath.parent.mkdir;
// if (!parent.isFolder()) parent.createFolder;
// ensure parent dir exists
// write file
auto fos=new File(filename, File.WriteCreate);
fos.output.write(data);
scope (exit) fos.close;
}
public static char[] getAbsoluteFileName(char[] filename) {
auto filepath=FilePath(Environment.get("HOME"));
filepath.append(ANTLRWORKS_DIR).append(filename);
return filepath.path;
}
}
|
D
|
module java.net.all;
public import java.net.MalformedURLException;
public import java.net.URL;
|
D
|
module bounce_direction;
enum BounceDirection
{
None,
Top,
Bottom,
Left,
Right
};
|
D
|
INSTANCE Focus_Normal (C_Focus)
{
// NSCs
npc_longrange = 500.0; // Nur im Normalmodus gueltig -- Horst:Nein auch im Melee modus wichtig!!Bei Fragen bitte an mich wenden
npc_range1 = 0.0;
npc_range2 = 300.0;
npc_azi = 30.0;
npc_elevup = 30.0;
npc_elevdo = -45.0;
npc_prio = 2;
// ITEMs
item_range1 = 0.0;
item_range2 = 300.0; // von 150 auf 130 -- Mike // von 130 auf 180 - Markus wegen Orcs // von 180 auf 300, man sieht sonst keine Items -Mike
item_azi = 30.0; // von 40 auf 20
item_elevup = 60.0;
item_elevdo = -89.0; // von -100 auf -89 -- geht eh nur bis -90 wegen azi! -- Mike
item_prio = 1;
// MOBs
mob_range1 = 0.0;
mob_range2 = 350.0;
mob_azi = 30.0;
mob_elevup = 89.0;
mob_elevdo = -89.0;
mob_prio = 0; // neu -- Mike
};
INSTANCE Focus_Melee (C_Focus)
{
// NSCs
//npc_longrange = 600.0; // FINGER WEG DA!!! -- Horst
npc_range1 = 0.0;
npc_range2 = 500.0;
npc_azi = 50.0; // - geändert von 30 auf 45 (Gothic 1) auf 50 (Gothic II) -- Mike
npc_elevup = 90.0;
npc_elevdo = -60.0;
npc_prio = 1; // NPCs(1) before MOBs(0)
// No ITEMs
item_prio = -1;
// MOBs
mob_range1 = 0.0;
mob_range2 = 150.0;
mob_azi = 30.0;
mob_elevup = 45.0;
mob_elevdo = -45.0;
mob_prio = -1; // MOBs(0) after NPCs(1)
};
INSTANCE Focus_Ranged (C_Focus)
{
// NSCs
npc_range1 = 0.0;
npc_range2 = 3500.0; //muss GLEICH FIGHT_DIST_CANCEL sein
npc_azi = 45.0;
npc_elevup = 90.0; //45
npc_elevdo = -85.0; //-45
npc_prio = 1; // NSCs werden bevorzugt
// ITEMs
item_range1 = 0.0;
item_range2 = 3000.0;
item_azi = 45.0;
item_elevup = 45.0;
item_elevdo = -45.0;
item_prio = -1;
// MOBs
mob_range1 = 0.0;
mob_range2 = 3000.0;
mob_azi = 45.0;
mob_elevup = 45.0;
mob_elevdo = -45.0;
mob_prio = -1;
};
INSTANCE Focus_Throw_Item (C_Focus)
{
// NSCs
npc_range1 = 300.0;
npc_range2 = 1500.0;
npc_azi = 20.0;
npc_elevup = 45.0;
npc_elevdo = -45.0;
// ITEMs
item_range1 = 300.0;
item_range2 = 1500.0;
item_azi = 20.0;
item_elevup = 45.0;
item_elevdo = -45.0;
// MOBs
mob_range1 = 300.0;
mob_range2 = 1500.0;
mob_azi = 20.0;
mob_elevup = 45.0;
mob_elevdo = -45.0;
};
INSTANCE Focus_Throw_Mob (C_Focus)
{
// NSCs
npc_range1 = 50.0;
npc_range2 = 200.0;
npc_azi = 20.0;
npc_elevup = 45.0;
npc_elevdo = -45.0;
// ITEMs
item_range1 = 50.0;
item_range2 = 200.0;
item_azi = 20.0;
item_elevup = 45.0;
item_elevdo = -45.0;
// MOBs
mob_range1 = 50.0;
mob_range2 = 200.0;
mob_azi = 20.0;
mob_elevup = 45.0;
mob_elevdo = -45.0;
};
// ACHTUNG!!!!!!!: Der Magie Fokus sollte nicht verändert werden. Alle spezifischen Focus Modes sind PRO SPELL in der Spell_Params.d einstellbar.
// Diese Magie Focus Instanz trifft die Vorentscheidung, welche Vobs überhaupt in Frage kommen. Der eigentlich Test findet in den einzelnen Spells statt!
INSTANCE Focus_Magic(C_Focus)
{
// NSCs
/* npc_range1 = 0.0;
npc_range2 = 30000.0;
npc_azi = 180.0;
npc_elevup = 90.0;
npc_elevdo = -90.0;
npc_prio = 2; // NSCs werden bevorzugt
// ITEMs
item_range1 = 0.0;
item_range2 = 30000.0;
item_azi = 180.0;
item_elevup = 90.0;
item_elevdo = -90.0;
item_prio = 0;
// MOBs
mob_range1 = 0.0;
mob_range2 = 30000.0;
mob_azi = 180.0;
mob_elevup = 90.0;
mob_elevdo = -90.0;
mob_prio = 0;*/
npc_range1 = 0.0;
npc_range2 = 3500.0; //muss GLEICH FIGHT_DIST_CANCEL sein
npc_azi = 45.0;
npc_elevup = 90.0;
npc_elevdo = -85.0;
npc_prio = 1; // MH: NUR NSCs werden berücksichtigt
// ITEMs
item_range1 = 0.0;
item_range2 = 3000.0;
item_azi = 45.0;
item_elevup = 45.0;
item_elevdo = -45.0;
item_prio = -1;
// MOBs
mob_range1 = 0.0;
mob_range2 = 3000.0;
mob_azi = 45.0;
mob_elevup = 45.0;
mob_elevdo = -45.0;
mob_prio = 0;
};
|
D
|
/**
* This is a special module and linked into each DSO (Dynamic Shared Object,
* i.e., DLL/.so/.dylib or executable), registering the binary with druntime.
*
* When linking against static druntime (or linking the shared druntime library
* itself), rt.sections_elf_shared pulls in this object file automatically.
*
* When linking against shared druntime, the compiler links in this
* object file automatically.
*/
module rt.dso;
pragma(LDC_no_moduleinfo); // not needed; avoid collision across shared druntime and other binaries
import ldc.attributes : hidden;
import rt.sections_elf_shared; // : CompilerDSOData, _d_dso_registry;
static if (is(CompilerDSOData)): // only for targets supporting rt.sections_elf_shared
version (OSX)
version = Darwin;
else version (iOS)
version = Darwin;
else version (TVOS)
version = Darwin;
else version (WatchOS)
version = Darwin;
private @hidden:
// dummy variable used to link this object file into the binary (ref'd from
// rt.sections_elf_shared)
extern(C) __gshared int __rt_dso_ref = 0;
__gshared CompilerDSOData dsoData;
__gshared void* dsoSlot;
version (Posix)
{
// Automatically registers this DSO with druntime.
pragma(crt_constructor)
void register_dso()
{
dsoData._version = 1;
dsoData._slot = &dsoSlot;
dsoData._minfo_beg = &__start___minfo;
dsoData._minfo_end = &__stop___minfo;
version (Darwin)
dsoData._getTLSAnchor = &getTLSAnchor;
_d_dso_registry(&dsoData);
}
// Automatically unregisters this DSO from druntime.
pragma(crt_destructor)
void unregister_dso()
{
_d_dso_registry(&dsoData);
}
// special symbols created by the linker:
extern(C) extern __gshared
{
version (Darwin)
{
pragma(mangle, "\1section$start$__DATA$.minfo")
immutable ModuleInfo* __start___minfo;
pragma(mangle, "\1section$end$__DATA$.minfo")
immutable ModuleInfo* __stop___minfo;
}
else
{
immutable ModuleInfo* __start___minfo;
immutable ModuleInfo* __stop___minfo;
}
}
version (Darwin)
{
align(16) byte tlsAnchor = 1;
extern(C) void* getTLSAnchor() nothrow @nogc
{
return &tlsAnchor;
}
}
}
else version (Windows)
{
// Automatically registers this DSO with druntime.
pragma(crt_constructor)
void register_dso()
{
dsoData._version = 1;
dsoData._slot = &dsoSlot;
dsoData._imageBase = cast(typeof(dsoData._imageBase)) &__ImageBase;
dsoData._getTLSRange = &getTLSRange;
_d_dso_registry(&dsoData);
// The default MSVCRT DllMain appears not to call `pragma(crt_destructor)`
// functions, not even when explicitly unloading via `FreeLibrary()`.
// Fortunately, registering an atexit handler inside the DSO seems to do
// the job just as well.
import core.stdc.stdlib : atexit;
atexit(&unregister_dso);
}
// Unregisters this DSO from druntime.
extern(C) void unregister_dso()
{
_d_dso_registry(&dsoData);
}
extern(C) extern __gshared
{
// special symbol created by the linker
void* __ImageBase;
// special symbols provided by the MSVC runtime
uint _tls_index;
void*[2] _tls_used; // start, end
}
// Returns the TLS range for the executing thread and this DSO.
void[] getTLSRange() nothrow @nogc
{
void** _tls_array;
version (Win32)
asm nothrow @nogc { "mov %%fs:(0x2C), %0" : "=r" (_tls_array); }
else version (Win64)
asm nothrow @nogc { "mov %%gs:0(%1), %0" : "=r" (_tls_array) : "r" (0x58); }
else
static assert(0);
void* pbeg = _tls_array[_tls_index];
const size = _tls_used[1] - _tls_used[0];
return pbeg[0 .. size];
}
}
|
D
|
measuring instrument for measuring the relative humidity of the atmosphere
|
D
|
// This file is part of Visual D
//
// Visual D integrates the D programming language into Visual Studio
// Copyright (c) 2010 by Rainer Schuetze, All Rights Reserved
//
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt
module c2d.ast;
import c2d.tokenizer;
import c2d.dlist;
import c2d.dgutil;
import c2d.tokutil;
import std.conv;
//////////////////////////////////////////////////////////////////////////////
debug = VERIFY;
//debug = TOKENTEXT;
bool tryRecover = true;
int syntaxErrors;
string syntaxErrorMessages;
// how to handle identifier in declaration
enum IdentPolicy
{
SingleMandantory, // not used
SingleOptional,
MultipleMandantory, // at least one must exist
MultipleOptional,
Prohibited
}
struct ToStringData
{
// options
bool noIdentifierInPrototype;
bool addScopeToIdentifier;
bool addClassPrefix;
bool addEnumPrefix;
bool addArgumentDefaults;
bool addFunctionBody;
// state variables
bool inDeclarator;
bool inPrototype;
}
alias DList!(AST) ASTList;
alias DListIterator!(AST) ASTIterator;
class AST
{
enum Type
{
// decl-children: DeclarationGroup, ConditionalDeclaration, Declaration, mixin-Expression, Protection
Module, // decl-children
Statement,
Declaration, // children: TypeDeclaration, VarDeclaration*
Protection,
CtorInitializer,
CtorInitializers,
TypeDeclaration,
EnumDeclaration,
VarDeclaration, // children: declarator Expression, init Expression
ConditionalDeclaration, // static if or version on declaration level
DeclarationGroup, // non-scoped group of declarations in conditional
PrimaryExp,
PostExp,
UnaryExp,
BinaryExp,
CondExp,
CastExp, // child0: decl, child1: expression
EmptyExp, // third arg in for
PPLine,
}
this(Type type)
{
_type = type;
}
void addChild(AST ast)
{
if(!children)
children = new DList!(AST);
children.append(ast);
ast._parent = this;
}
//////////////////////////////////////////////////////////////
void insertChildBefore(ASTIterator it, AST ast, TokenList toklist, TokenIterator* pInsertPos = null)
{
bool insertAtStart = !children || children.empty();
if(!children)
{
children = new DList!(AST);
children.append(ast);
it = children.end();
}
else
it.insertBefore(ast);
ast._parent = this;
// it on child after inserted ast
TokenIterator insertPos;
if(pInsertPos)
insertPos = *pInsertPos;
else if(insertAtStart)
insertPos = defaultInsertStartTokenPosition();
else if (it.atEnd())
insertPos = defaultInsertEndTokenPosition();
else
insertPos = it.start;
insertPos.insertListBefore(toklist); // insertPos now points after inserted token list
ast.fixIteratorList(start.getList());
if(ast.start != ast.end)
{
if(AST prev = ast.prevSibling())
fixIteratorChildrenEnd(prev, insertPos, ast.start);
else
fixIteratorParentsStart(this, insertPos, ast.start);
if(AST next = ast.nextSibling())
fixIteratorChildrenEnd(ast, ast.end, insertPos);
else
fixIteratorChildrenEnd(ast, ast.end, insertPos);
}
debug(TOKENTEXT) verify();
}
void appendChild(AST ast, TokenList toklist)
{
ASTIterator it;
if(children)
it = children.end();
insertChildBefore(it, ast, toklist);
}
void prependChild(AST ast, TokenList toklist)
{
ASTIterator it;
if(children)
it = children.begin();
insertChildBefore(it, ast, toklist);
}
TokenList removeChild(AST ast, bool keepComments = false)
{
assume(children && ast._parent == this);
ASTIterator it = children.find(ast);
assume(!it.atEnd());
TokenIterator end = ast.end;
if(keepComments)
{
while(ast.start != end)
{
if(!isCommentToken(end[-1]))
break;
end.retreat();
}
}
if(ast.start != end)
{
if(AST prev = ast.prevSibling())
fixIteratorChildrenEnd(prev, ast.start, end);
else
fixIteratorParentsStart(this, ast.start, end);
}
TokenList list = (ast.start + 0).eraseUntil(end);
fixIteratorChildrenEnd(ast, ast.end, list.end());
it.erase();
ast.fixIteratorList(list);
ast._parent = null;
debug(TOKENTEXT) verify();
return list;
}
int countChildren()
{
if(!children)
return 0;
return children.count();
}
ASTIterator childrenBegin()
{
if(!children)
return ASTIterator();
return children.begin();
}
//////////////////////////////////////////////////////////////
void insertTokenListBefore(AST child, TokenList toklist)
{
assume(true || child._parent is this);
TokenIterator insertPos;
if(!child)
insertPos = end;
else
insertPos = child.start;
TokenIterator begIt = insertPos.insertListBefore(toklist);
if(child)
if(AST prev = child.prevSibling())
fixIteratorChildrenEnd(prev, insertPos, begIt);
fixIteratorParentsStart(this, insertPos, begIt);
}
void insertTokenBefore(AST child, Token tok)
{
TokenList toklist = new TokenList;
toklist.append(tok);
insertTokenListBefore(child, toklist);
}
void removeToken(TokenIterator removeIt)
{
AST prevChild;
void _removeToken()
{
if(prevChild)
fixIteratorChildrenEnd(prevChild, removeIt, removeIt + 1);
fixIteratorParentsStart(this, removeIt, removeIt + 1);
removeIt.erase();
}
TokenIterator tokIt = start;
if(children)
{
for(ASTIterator it = children.begin(); !it.atEnd(); ++it)
{
for( ; tokIt != it.start; ++tokIt)
if(removeIt == tokIt)
{
_removeToken();
return;
}
tokIt = it.end;
prevChild = *it;
}
}
for( ; tokIt != end; ++tokIt)
if(removeIt == tokIt)
{
_removeToken();
return;
}
assume(false, "token not part of AST");
}
void removeToken(int toktype)
{
TokenIterator tokIt = start;
while(tokIt != end && tokIt.type != toktype)
tokIt.advance();
if(tokIt != end)
removeToken(tokIt);
}
//////////////////////////////////////////////////////////////
AST prevSibling()
{
if(!_parent)
return null;
assume(_parent.children, "inconsistent AST");
ASTIterator it = _parent.children.begin();
if(it.atEnd() || *it is this)
return null;
for(++it; !it.atEnd(); ++it)
if(*it is this)
return it[-1];
assume(false, "inconsistent AST");
return null;
}
AST nextSibling()
{
if(!_parent)
return null;
assume(_parent.children, "inconsistent AST");
ASTIterator it = _parent.children.find(this);
assume(!it.atEnd(), "inconsistent AST");
++it;
if(it.atEnd())
return null;
return *it;
}
static void fixIteratorChildrenEnd(AST ast, TokenIterator end, TokenIterator newEnd)
{
while(ast && ast.end == end)
{
if(ast.children && !ast.children.empty())
fixIteratorChildrenEnd(ast.children.end()[-1], end, newEnd);
ast.end = newEnd;
if(ast.start != end)
break;
ast.start = newEnd;
ast = ast.prevSibling();
}
}
static void fixIteratorParentsStart(AST ast, TokenIterator start, TokenIterator newStart)
{
while(ast && start == ast.start)
{
if(AST prev = ast.prevSibling())
fixIteratorChildrenEnd(prev, start, newStart);
if(ast._parent)
fixIteratorParentsStart(ast._parent, start, newStart);
ast.start = newStart;
if(ast.end != start)
break;
ast = ast.nextSibling();
}
}
void fixIteratorList(TokenList list)
{
start.setList(list);
end.setList(list);
if(children)
for(ASTIterator it = children.begin(); !it.atEnd(); ++it)
it.fixIteratorList(list);
}
//////////////////////////////////////////////////////////////
void verifyIteratorList(ref TokenIterator tokIt)
{
if(tokIt.getList() != start.getList())
assume(tokIt.getList() == start.getList());
debug(TOKENTEXT) toktext = tokenListToString(start, end);
while(tokIt != start)
tokIt.advance();
if(children)
for(ASTIterator it = children.begin(); !it.atEnd(); ++it)
it.verifyIteratorList(tokIt);
assume(tokIt.getList() == end.getList());
while(tokIt != end)
tokIt.advance();
}
void verifyChildren()
{
if(children)
for(ASTIterator it = children.begin(); !it.atEnd(); ++it)
{
assume(it._parent is this);
it.verifyChildren();
}
}
final void verify()
{
debug(VERIFY)
{
TokenIterator tokIt = start;
verifyIteratorList(tokIt);
verifyChildren();
}
}
//////////////////////////////////////////////////////////////
AST getRoot()
{
AST ast = this;
while(ast._parent)
ast = ast._parent;
return ast;
}
TokenIterator defaultInsertStartTokenPosition()
{
return start;
}
TokenIterator defaultInsertEndTokenPosition()
{
return end;
}
static void recoverFromSyntaxError(Exception e, ref TokenIterator tokIt)
{
if(!tryRecover)
throw e;
syntaxErrors++;
syntaxErrorMessages ~= "$FILENAME$" ~ e.msg ~ "\n";
if(!tokIt.atEnd())
tokIt.pretext ~= " /* SYNTAX ERROR: " ~ e.msg ~ " */ ";
while(!tokIt.atEnd() && tokIt.type != Token.EOF &&
tokIt.type != Token.BraceR && tokIt.type != Token.Semicolon)
nextToken(tokIt);
if(!tokIt.atEnd() && tokIt.type == Token.Semicolon)
nextToken(tokIt);
}
//////////////////////////////////////////////////////////////////////
AST parseProtection(ref TokenIterator tokIt)
{
AST prot = new AST(Type.Protection);
prot.start = tokIt;
nextToken(tokIt); // checked by caller
checkToken(tokIt, Token.Colon);
prot.end = tokIt;
return prot;
}
//////////////////////////////////////////////////////////////////////
void parseDeclarations(ref TokenIterator tokIt, string className = "")
{
// extern "C" { and namespace only allowed on highest level and thrown away
while(!tokIt.atEnd() && tokIt.type != Token.EOF && tokIt.type != Token.BraceR)
{
TokenIterator start = tokIt;
try
{
switch(tokIt.type)
{
case Token.Namespace:
nextToken(tokIt);
if(tokIt.type == Token.Identifier)
nextToken(tokIt);
checkToken(tokIt, Token.BraceL);
DeclGroup grp = new DeclGroup;
grp.parseDeclarations(tokIt);
checkToken(tokIt, Token.BraceR);
grp.start = start;
grp.end = tokIt;
addChild(grp);
break;
case Token.Extern:
if(tokIt[1].type == Token.String)
{
tokIt[1].text = "(" ~ tokIt[1].text[1..$-1] ~ ")";
nextToken(tokIt);
nextToken(tokIt);
if(tokIt.type == Token.BraceL)
{
nextToken(tokIt);
DeclGroup grp = new DeclGroup;
grp.parseDeclarations(tokIt);
checkToken(tokIt, Token.BraceR);
grp.start = start;
grp.end = tokIt;
addChild(grp);
break;
}
}
// otherwise fall through to normal declaration
goto default;
case Token.Version:
case Token.Static_if:
addChild(Declaration.parseStaticIfVersion(tokIt));
break;
case Token.Mixin:
addChild(Expression.parsePrimaryExp(tokIt));
checkToken(tokIt, Token.Semicolon);
break;
case Token.Tilde:
case Token.Identifier:
if(className.length > 0 && DeclType.isProtection(tokIt.text))
{
addChild(parseProtection(tokIt));
break;
}
bool isDtor;
int len = Declaration.isCtorDtor(tokIt, isDtor, className);
if(len > 0)
{
addChild(Declaration.parseCtorDtor(tokIt, len, isDtor));
break;
}
goto default; // otherwise fall through
default:
Declaration decl = Declaration.parseDeclaration(tokIt);
addChild(decl);
break;
}
}
catch(Exception e)
{
recoverFromSyntaxError(e, tokIt);
auto dtype = new DeclType(DeclType.Basic, "error");
Declaration decl = new Declaration(dtype);
decl.start = dtype.start = start;
decl.end = dtype.end = tokIt;
addChild(decl);
}
}
}
void parseArguments(ref TokenIterator tokIt, int terminator)
{
// inserts expression as children into this
if(tokIt.type != terminator)
{
for ( ; ; )
{
Expression e = Expression.parseAssignExp(tokIt);
addChild(e);
if(tokIt.type == terminator)
break;
checkToken(tokIt, Token.Comma);
if(tokIt.type == terminator) // allow empty initializer after comma
break;
}
}
}
void parseDeclArguments(ref TokenIterator tokIt, int terminator)
{
// inserts expression as children into this
if(tokIt.type != terminator)
{
for ( ; ; )
{
if(tokIt.type == Token.Elipsis)
{
DeclType decltype = new DeclType(DeclType.Elipsis, "");
decltype.start = tokIt;
nextToken(tokIt);
decltype.end = tokIt;
Declaration decl = new Declaration(decltype);
decl.start = decltype.start;
decl.end = decltype.end;
addChild(decl);
}
else
{
Declaration decl = Declaration.parseDeclaration(tokIt, IdentPolicy.SingleOptional);
addChild(decl);
}
if(tokIt.type == terminator)
break;
checkToken(tokIt, Token.Comma);
}
}
}
//////////////////////////////////////////////////////////////////////
void parseModule(ref TokenIterator tokIt)
{
start = tokIt;
retry:
skipComments(tokIt);
//parseStatements(tokIt);
parseDeclarations(tokIt);
if(!tokIt.atEnd() && tokIt.type == Token.BraceR)
{
string msg = "unexpected trailing }";
syntaxErrors++;
syntaxErrorMessages ~= "$FILENAME$" ~ "(" ~ to!string(tokIt.lineno) ~ "): " ~ msg ~ "\n";
tokIt.pretext ~= " /* SYNTAX ERROR: " ~ msg ~ " */ ";
tokIt.advance();
goto retry;
}
end = tokIt;
if(!tokIt.atEnd() && tokIt.type != Token.EOF)
throwException((*tokIt).lineno, "not parsed until the end of the file");
addEnumerators();
}
//////////////////////////////////////////////////////////////////////
string toString(ref ToStringData tsd)
{
throwException(start.lineno, "toString(tsd) not implemented!");
return "<not implemented>";
}
long evaluate()
{
throwException(start.lineno, "evaluate() not implemented!");
return 0;
}
string getScope()
{
string txt;
for(AST parent = _parent; parent; parent = parent._parent)
{
switch(parent._type)
{
case Type.DeclarationGroup:
if(parent.start.type == Token.Namespace)
txt = parent.start[1].text ~ "::" ~ txt;
break;
case Type.ConditionalDeclaration:
case Type.PrimaryExp: // for mixin
break;
case Type.Declaration:
Declaration decl = cast(Declaration) parent;
if (DeclType dtype = isClassDefinition(decl))
txt = dtype._ident ~ "::" ~ txt;
break;
default:
break;
}
}
return txt;
}
AST clone()
{
AST ast = new AST(_type);
cloneChildren(ast);
return ast;
}
void cloneChildren(AST ast)
{
ast.start = start;
if(children)
for(ASTIterator it = children.begin(); !it.atEnd(); ++it)
ast.addChild(it.clone());
ast.end = end;
}
//////////////////////////////////////////////////////////////////////
void reassignTokens(ref TokenIterator cloneIt)
{
TokenIterator tokIt = start;
start = cloneIt;
if(children)
for(ASTIterator it = children.begin(); !it.atEnd(); ++it)
{
while(tokIt != it.start)
{
tokIt.advance();
cloneIt.advance();
}
tokIt = it.end;
it.reassignTokens(cloneIt);
}
while(tokIt != end)
{
tokIt.advance();
cloneIt.advance();
}
end = cloneIt;
}
TokenList cloneTokens(bool copyTokens = true)
{
TokenList toklist = copyTokenList(start, end, copyTokens);
TokenIterator tokIt = toklist.begin();
reassignTokens(tokIt);
return toklist;
}
//////////////////////////////////////////////////////////////////////
void addEnumerators()
{
if(_type == Type.Declaration && children && !children.empty())
if(DeclType dtype = cast(DeclType) children[0])
{
if(dtype._dtype == DeclType.Enum)
if(dtype.children)
{
string scp = getScope();
if(dtype._ident)
scp ~= dtype._ident ~ "::";
for(ASTIterator it = dtype.children.begin(); !it.atEnd(); ++it)
if(DeclVar var = cast(DeclVar) *it)
addEnumIdentifier(scp, var._ident);
}
if(dtype._dtype == DeclType.Basic && dtype._ident == "__enum")
{
string scp = getScope();
for(ASTIterator it = children.begin() + 1; !it.atEnd(); ++it)
if(DeclVar var = cast(DeclVar) *it)
addEnumIdentifier(scp, var._ident);
}
}
if(children)
for(ASTIterator it = children.begin(); !it.atEnd(); ++it)
it.addEnumerators();
}
//////////////////////////////////////////////////////////////////////
static void addInheritence(string base, string derived)
{
if(derived in baseClass)
{
if(base != baseClass[derived])
throwException("different base classes for " ~ derived);
return;
}
baseClass[derived] = base;
derivedClasses[base] ~= derived;
}
static bool isPOD(string className)
{
int loop = 0;
while(loop++ < 20)
{
if(className in baseClass)
return false;
if(className in derivedClasses)
return false;
if(auto p = className in typedefIdentifier)
className = *p;
else
break;
}
return true;
}
static void addEnumIdentifier(string enumName, string enumIdent)
{
if(enumName.length)
enumIdentifier[enumIdent] = enumName;
}
static bool isBaseClass(string base, string derived)
{
if(string *ps = derived in baseClass)
return *ps == base;
return false;
}
static void addTypedef(DeclType dtype, DeclVar dvar)
{
if(dvar._ident.length == 0 || dtype._ident.length == 0)
return;
if(dvar._ident in typedefIdentifier)
return;
if(dvar.children && !dvar.children.empty && dvar.children[0]._type != Type.PrimaryExp)
return;
typedefIdentifier[dvar._ident] = dtype._ident;
}
//////////////////////////////////////////////////////////////////////
TokenIterator start; // first token
TokenIterator end; // token after last token
debug(TOKENTEXT) string toktext;
DList!(AST) children;
AST _parent;
Type _type;
//////////////////////////////////////////////////////////////////////
static string[string] baseClass;
static string[][string] derivedClasses;
static string[string] enumIdentifier;
static string[string] typedefIdentifier;
// call this to cleanup garbage from unittests
static void clearStatic()
{
string[string] ini1;
baseClass = ini1; // = baseClass.init;
string[][string] ini2;
derivedClasses = ini2; // = derivedClasses.init;
string[string] ini3;
enumIdentifier = ini3; // = enumIdentifier.init;
typedefIdentifier = ini3; // = enumIdentifier.init;
}
}
/********************************* Expression Parser ***************************/
class Expression : AST
{
int _toktype;
this(Type type, int toktype, Expression child1 = null, Expression child2 = null, Expression child3 = null)
{
_toktype = toktype;
super(type);
if(child1)
addChild(child1);
if(child2)
addChild(child2);
if(child3)
addChild(child3);
}
static Expression parseFullExpression(ref TokenIterator tokIt)
{
return parseCommaExp(tokIt);
}
static Expression parsePrimaryExp(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
Expression e;
switch (start.type)
{
case Token.DoubleColon:
nextToken(tokIt);
goto L_doubleColon;
case Token.Identifier:
nextToken(tokIt);
while(tokIt.type == Token.DoubleColon)
{
nextToken(tokIt);
L_doubleColon:
if(tokIt.type == Token.Operator)
{
nextToken(tokIt);
checkOperator(tokIt);
}
else
checkToken(tokIt, Token.Identifier);
}
e = new Expression(Type.PrimaryExp, Token.Identifier);
break;
case Token.Operator:
nextToken(tokIt);
checkOperator(tokIt);
e = new Expression(Type.PrimaryExp, Token.Operator);
break;
case Token.This:
case Token.Number:
nextToken(tokIt);
e = new Expression(Type.PrimaryExp, start.type);
break;
case Token.String:
nextToken(tokIt);
while(tokIt.type == Token.String) // concatenate strings
nextToken(tokIt);
e = new Expression(Type.PrimaryExp, start.type);
break;
case Token.Mixin:
nextToken(tokIt);
checkToken(tokIt, Token.ParenL);
e = new Expression(Type.PrimaryExp, Token.Mixin, parseFullExpression(tokIt));
checkToken(tokIt, Token.ParenR);
break;
case Token.Sizeof:
nextToken(tokIt);
if(tokIt.type != Token.ParenL)
{
e = new Expression(Type.PrimaryExp, Token.Sizeof, parseUnaryExp(tokIt));
}
else if(isTypeInParenthesis(tokIt) > 0)
{
nextToken(tokIt);
Declaration decl = Declaration.parseDeclaration(tokIt, IdentPolicy.Prohibited);
e = new Expression(Type.PrimaryExp, Token.Sizeof);
e.addChild(decl);
checkToken(tokIt, Token.ParenR);
}
else
{
nextToken(tokIt);
e = new Expression(Type.PrimaryExp, Token.Sizeof, parseFullExpression(tokIt));
checkToken(tokIt, Token.ParenR);
}
break;
case Token.ParenL:
nextToken(tokIt);
e = new Expression(Type.PrimaryExp, Token.ParenL, parseFullExpression(tokIt));
checkToken(tokIt, Token.ParenR);
break;
case Token.BraceL:
nextToken(tokIt);
e = new Expression(Type.PrimaryExp, Token.BraceL);
e.parseArguments(tokIt, Token.BraceR);
checkToken(tokIt, Token.BraceR);
break;
case Token.Static_cast, Token.Dynamic_cast, Token.Reinterpret_cast, Token.Const_cast:
nextToken(tokIt);
checkToken(tokIt, Token.LessThan);
Declaration decl = Declaration.parseDeclaration(tokIt, IdentPolicy.Prohibited);
e = new Expression(Type.CastExp, start.type);
e.addChild(decl);
checkToken(tokIt, Token.GreaterThan);
checkToken(tokIt, Token.ParenL);
e.addChild(parseFullExpression(tokIt));
checkToken(tokIt, Token.ParenR);
break;
default:
throwException(tokIt.lineno, "expression expected, not " ~ tokIt.text);
}
e.start = start;
e.end = tokIt;
return e;
}
static Expression parsePostExp(ref TokenIterator tokIt, Expression e)
{
TokenIterator start = e.start; // sub-expression e included
int startType = tokIt.type;
switch (startType)
{
case Token.Deref:
case Token.Dot:
nextToken(tokIt);
e = new Expression(Type.PostExp, startType, e); // identifier as primary expression
Expression idexpr = new Expression(Type.PrimaryExp, Token.Identifier);
idexpr.start = tokIt;
checkToken(tokIt, Token.Identifier);
while(tokIt.type == Token.DoubleColon)
{
nextToken(tokIt);
checkToken(tokIt, Token.Identifier);
}
idexpr.end = tokIt;
e.addChild(idexpr);
break;
case Token.PlusPlus:
case Token.MinusMinus:
nextToken(tokIt);
e = new Expression(Type.PostExp, startType, e);
break;
case Token.ParenL:
// currently includes casts
nextToken(tokIt);
e = new Expression(Type.PostExp, Token.ParenL, e);
e.parseArguments(tokIt, Token.ParenR);
checkToken(tokIt, Token.ParenR);
break;
case Token.BracketL:
nextToken(tokIt);
e = new Expression(Type.PostExp, Token.BracketL, e, parseFullExpression(tokIt));
checkToken(tokIt, Token.BracketR);
break;
default:
return e;
}
e.start = start;
e.end = tokIt;
return parsePostExp(tokIt, e);
}
static Expression parseDeleteExp(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
checkToken(tokIt, Token.Delete);
if(tokIt.type == Token.BracketL)
{
nextToken(tokIt);
checkToken(tokIt, Token.BracketR);
}
Expression e = new Expression(Type.UnaryExp, Token.Delete, parseUnaryExp(tokIt));
e.start = start;
e.end = tokIt;
return e;
}
static Expression parseNewExp(ref TokenIterator tokIt)
{
throwException(tokIt.lineno, "not implemented");
return null;
}
//////////////////////////////////////////////////////////////////////
static int isTypeInParenthesis(TokenIterator tokIt)
{
TokenIterator close;
return isTypeInParenthesis(tokIt, close);
}
// return -1 if not type, 0 if undecided, 1 if type
static int isTypeInParenthesis(TokenIterator tokIt, ref TokenIterator close)
{
TokenIterator it = tokIt + 1;
if(DeclType.isBasicType(it.text) || DeclType.isTypeModifier(it.text))
return 1;
switch(it.type)
{
case Token.Enum:
case Token.Struct:
case Token.Union:
case Token.Class:
case Token.Interface:
return 1;
case Token.Identifier:
break;
default:
return -1;
}
close = tokIt;
TokenIterator noStop;
advanceToClosingBracket(close, noStop);
// close after ')'
if(close[-2].type == Token.Asterisk)
return 1;
return 0;
}
static bool isCast(TokenIterator tokIt)
{
TokenIterator close;
int res = isTypeInParenthesis(tokIt, close);
if(res != 0)
return res > 0;
switch(close.type)
{
case Token.Identifier:
case Token.Number:
case Token.String:
case Token.ParenL:
case Token.This:
return true;
default:
return false;
}
}
static Expression parseUnaryExp(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
Expression e;
switch (start.type)
{
case Token.Ampersand:
case Token.Asterisk:
case Token.PlusPlus:
case Token.MinusMinus:
case Token.Minus:
case Token.Plus:
case Token.Exclamation:
case Token.Tilde:
case Token.New:
nextToken(tokIt);
e = new Expression(Type.UnaryExp, start.type, parseUnaryExp(tokIt));
break;
case Token.Delete:
return parseDeleteExp(tokIt);
case Token.ParenL:
if(isCast(tokIt))
{
nextToken(tokIt);
Declaration decl = Declaration.parseDeclaration(tokIt, IdentPolicy.Prohibited);
checkToken(tokIt, Token.ParenR);
Expression expr = parseUnaryExp(tokIt);
e = new Expression(Type.CastExp, Token.ParenL);
e.addChild(decl);
e.addChild(expr);
break;
}
goto default; // fall through
default:
e = parsePrimaryExp(tokIt);
e = parsePostExp(tokIt, e);
return e;
}
e.start = start;
e.end = tokIt;
return e;
}
alias Expression fnParseExp(ref TokenIterator);
static Expression parseBinaryExp(tokens...) (fnParseExp* fn, ref TokenIterator tokIt) // binaryParseFn fn,
{
TokenIterator start = tokIt;
Expression e = fn(tokIt); // fn(tokIt);
L_nextExpr:
foreach(int type; tokens)
if(tokIt.type == type)
{
nextToken(tokIt);
e = new Expression(Type.BinaryExp, type, e, fn(tokIt));
e.start = start;
e.end = tokIt;
goto L_nextExpr;
}
return e;
}
static Expression parseMulExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.Asterisk, Token.Div, Token.Mod)(&parseUnaryExp, tokIt);
}
static Expression parseAddExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.Plus, Token.Minus, Token.Tilde)(&parseMulExp, tokIt);
}
static Expression parseShiftExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.Shl, Token.Shr)(&parseAddExp, tokIt);
}
static Expression parseRelExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.LessThan, Token.LessEq, Token.GreaterThan, Token.GreaterEq,
Token.Unordered, Token.LessGreater, Token.LessEqGreater, Token.UnordGreater,
Token.UnordGreaterEq, Token.UnordLess, Token.UnordLessEq, Token.UnordEq)
(&parseShiftExp, tokIt);
}
static Expression parseEqualExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.Equal, Token.Unequal)(&parseRelExp, tokIt);
}
static Expression parseAndExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.Ampersand)(&parseEqualExp, tokIt);
}
static Expression parseXorExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.Xor)(&parseAndExp, tokIt);
}
static Expression parseOrExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.Or)(&parseXorExp, tokIt);
}
static Expression parseAndAndExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.AmpAmpersand)(&parseOrExp, tokIt);
}
static Expression parseOrOrExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.OrOr)(&parseAndAndExp, tokIt);
}
static Expression parseCondExp(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
Expression e = parseOrOrExp(tokIt);
if (tokIt.type != Token.Question)
return e;
nextToken(tokIt);
Expression eif = parseFullExpression(tokIt);
checkToken(tokIt, Token.Colon);
Expression eelse = parseCondExp(tokIt);
e = new Expression(Type.CondExp, Token.Question, e, eif, eelse);
e.start = start;
e.end = tokIt;
return e;
}
static Expression parseAssignExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.Assign, Token.AddAsgn, Token.SubAsgn, Token.MulAsgn,
Token.DivAsgn, Token.ModAsgn, Token.AndAsgn, Token.XorAsgn, Token.OrAsgn,
Token.ShlAsgn, Token.ShrAsgn)
(&parseCondExp, tokIt);
}
static Expression parseCommaExp(ref TokenIterator tokIt)
{
return parseBinaryExp!(Token.Comma)(&parseAssignExp, tokIt);
}
//////////////////////////////////////////////////////////////////////
// declaration expression
static Expression parsePrimaryDeclExp(ref TokenIterator tokIt, IdentPolicy idpolicy)
{
TokenIterator start = tokIt;
Expression e;
switch (start.type)
{
case Token.DoubleColon:
nextToken(tokIt);
goto L_doubleColon;
case Token.Identifier:
nextToken(tokIt);
while(tokIt.type == Token.DoubleColon)
{
nextToken(tokIt);
L_doubleColon:
if(tokIt.type == Token.Operator)
{
nextToken(tokIt);
checkOperator(tokIt);
}
else
checkToken(tokIt, Token.Identifier);
}
e = new Expression(Type.PrimaryExp, Token.Identifier);
break;
case Token.Operator:
nextToken(tokIt);
checkOperator(tokIt);
e = new Expression(Type.PrimaryExp, Token.Operator);
break;
case Token.Number:
case Token.String:
nextToken(tokIt);
e = new Expression(Type.PrimaryExp, start.type);
break;
case Token.ParenL:
nextToken(tokIt);
e = new Expression(Type.PrimaryExp, Token.ParenL, parseDeclModifierExp(tokIt, idpolicy, false));
checkToken(tokIt, Token.ParenR);
break;
default:
if(idpolicy == IdentPolicy.Prohibited ||
idpolicy == IdentPolicy.SingleOptional || idpolicy == IdentPolicy.MultipleOptional)
e = new Expression(Type.PrimaryExp, Token.Empty);
else
throwException(tokIt.lineno, "expression expected, not " ~ tokIt.text);
}
e.start = start;
e.end = tokIt;
return e;
}
static Expression parsePostDeclExp(ref TokenIterator tokIt, Expression e, IdentPolicy idpolicy)
{
TokenIterator start = e.start; // sub-expression e included
switch (tokIt.type)
{
case Token.ParenL:
// currently includes casts
nextToken(tokIt);
e = new Expression(Type.PostExp, Token.ParenL, e);
e.parseDeclArguments(tokIt, Token.ParenR);
checkToken(tokIt, Token.ParenR);
break;
case Token.BracketL:
nextToken(tokIt);
e = new Expression(Type.PostExp, Token.BracketL, e);
if(tokIt.type != Token.BracketR)
e.addChild(parseFullExpression(tokIt));
checkToken(tokIt, Token.BracketR);
break;
case Token.Colon:
nextToken(tokIt);
if(tokIt.type != Token.Number && tokIt.type != Token.Identifier)
throwException(tokIt.lineno, "number or identifier expected for bitfield size");
e = new Expression(Type.PostExp, Token.Colon, e, parsePrimaryDeclExp (tokIt, idpolicy));
break;
default:
return e;
}
e.start = start;
e.end = tokIt;
return parsePostDeclExp(tokIt, e, idpolicy);
}
static Expression parseUnaryDeclExp(ref TokenIterator tokIt, IdentPolicy idpolicy)
{
TokenIterator start = tokIt;
Expression e;
switch (start.type)
{
case Token.Ampersand:
case Token.Asterisk:
nextToken(tokIt);
DeclType.skipModifiers(tokIt);
e = new Expression(Type.UnaryExp, start.type, parseUnaryDeclExp(tokIt, idpolicy));
break;
default:
e = parsePrimaryDeclExp(tokIt, idpolicy);
e = parsePostDeclExp(tokIt, e, idpolicy);
return e;
}
e.start = start;
e.end = tokIt;
return e;
}
static Expression parseDeclModifierExp(ref TokenIterator tokIt, IdentPolicy idpolicy, bool declstmt)
{
TokenIterator start = tokIt;
DeclType.skipModifiers(tokIt);
Expression e = parseDeclExp(tokIt, idpolicy, declstmt);
e.start = start;
return e;
}
static Expression parseDeclExp(ref TokenIterator tokIt, IdentPolicy idpolicy, bool declstmt)
{
TokenIterator start = tokIt;
Expression e;
bool funcLike = start.type == Token.Identifier && start[1].type == Token.ParenL;
if(funcLike)
// two identifier following '(' looks like a function prototype
if(start[2].type == Token.Identifier && start[3].type == Token.Identifier)
funcLike = false;
if(declstmt && funcLike)
{
// reverse order to avoid most exceptions
try
{
e = parsePrimaryExp(tokIt);
e = parsePostExp(tokIt, e);
}
catch(SyntaxException)
{
tokIt = start;
e = parseUnaryDeclExp(tokIt, idpolicy);
}
}
else
{
try
{
e = parseUnaryDeclExp(tokIt, idpolicy);
}
catch(SyntaxException)
{
// expecting function like var initializer
tokIt = start;
e = parsePrimaryExp(tokIt);
e = parsePostExp(tokIt, e);
}
}
return e;
}
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
override Expression clone()
{
Expression expr = new Expression(_type, _toktype);
cloneChildren(expr);
return expr;
}
override string toString(ref ToStringData tsd)
{
string txt;
switch(_type)
{
case Type.PrimaryExp:
switch(_toktype)
{
case Token.Empty:
break;
case Token.Identifier:
case Token.Operator:
case Token.This:
case Token.Tilde:
if(!tsd.inPrototype || !tsd.noIdentifierInPrototype)
{
txt = tokensToIdentifier(start, end);
if(tsd.addScopeToIdentifier && !tsd.inPrototype)
txt = getScope() ~ txt;
}
break;
case Token.Number:
txt = start.text;
break;
case Token.ParenL:
txt = "(" ~ children[0].toString(tsd) ~ ")";
break;
case Token.BraceL:
txt = "{";
string prefix = " ";
for(ASTIterator it = children.begin() + 1; !it.atEnd(); ++it)
{
txt ~= prefix ~ it.toString(tsd);
prefix = ", ";
}
txt ~= " }";
break;
case Token.String:
txt = "\"" ~ start.text ~ "\"";
break;
case Token.Sizeof:
txt = "sizeof(" ~ children[0].toString(tsd) ~ ")";
break;
case Token.Mixin:
txt = "mixin(" ~ children[0].toString(tsd) ~ ")";
break;
default:
assume(0);
}
break;
case Type.PostExp:
switch(_toktype)
{
case Token.Deref:
case Token.Dot:
txt = children[0].toString(tsd) ~ Token.toString(_toktype) ~ children[1].toString(tsd);
break;
case Token.PlusPlus:
case Token.MinusMinus:
txt = children[0].toString(tsd) ~ Token.toString(_toktype);
break;
case Token.ParenL:
txt = children[0].toString(tsd);
txt ~= "(";
bool wasInPrototype = tsd.inPrototype;
scope(exit) tsd.inPrototype = wasInPrototype;
if(tsd.inDeclarator)
tsd.inPrototype = true;
string prefix = "";
for(ASTIterator it = children.begin() + 1; !it.atEnd(); ++it)
{
txt ~= prefix ~ it.toString(tsd);
prefix = ", ";
}
txt ~= ")";
break;
case Token.BracketL:
txt = children[0].toString(tsd) ~ "[";
bool wasInPrototype = tsd.inPrototype;
scope(exit) tsd.inPrototype = wasInPrototype;
if(tsd.inDeclarator)
tsd.inPrototype = false;
if(children.count() > 1)
{
bool wasAddScopeToIdentifier = tsd.addScopeToIdentifier;
scope(exit) tsd.addScopeToIdentifier = wasAddScopeToIdentifier;
tsd.addScopeToIdentifier = false;
txt ~= children[1].toString(tsd);
}
txt ~= "]";
break;
default:
assume(0);
}
break;
case Type.UnaryExp:
switch(_toktype)
{
case Token.Ampersand:
case Token.Asterisk:
case Token.PlusPlus:
case Token.MinusMinus:
case Token.Minus:
case Token.Plus:
case Token.Exclamation:
case Token.Tilde:
txt = Token.toString(_toktype) ~ children[0].toString(tsd);
break;
case Token.New:
case Token.Delete:
txt = Token.toString(_toktype) ~ " " ~ children[0].toString(tsd);
break;
default:
assume(0);
}
break;
case Type.EmptyExp:
break;
case Type.BinaryExp:
switch(_toktype)
{
case Token.Asterisk, Token.Div, Token.Mod,
Token.Plus, Token.Minus, Token.Tilde,
Token.Shl, Token.Shr,
Token.LessThan, Token.LessEq, Token.GreaterThan, Token.GreaterEq,
Token.Unordered, Token.LessGreater, Token.LessEqGreater, Token.UnordGreater,
Token.UnordGreaterEq, Token.UnordLess, Token.UnordLessEq, Token.UnordEq,
Token.Equal, Token.Unequal,
Token.Ampersand,
Token.Xor,
Token.Or,
Token.AmpAmpersand,
Token.OrOr,
Token.Assign, Token.AddAsgn, Token.SubAsgn, Token.MulAsgn,
Token.DivAsgn, Token.ModAsgn, Token.AndAsgn, Token.XorAsgn, Token.OrAsgn,
Token.ShlAsgn, Token.ShrAsgn,
Token.Comma:
txt = children[0].toString(tsd) ~ " " ~ Token.toString(_toktype) ~ " " ~ children[1].toString(tsd);
break;
default:
assume(0);
}
break;
case Type.CondExp:
txt = children[0].toString(tsd) ~ " ? " ~ children[1].toString(tsd) ~ " : " ~ children[2].toString(tsd);
break;
case Type.CastExp:
txt = "(" ~ children[0].toString(tsd) ~ ")" ~ children[1].toString(tsd);
break;
default:
assume(0);
}
return txt;
}
override long evaluate()
{
switch(_type)
{
default:
break;
case Type.PrimaryExp:
switch(_toktype)
{
default:
break;
case Token.Identifier:
return 0; // undefined identifier
case Token.Number:
return parse!long(start.text);
case Token.ParenL:
return children[0].evaluate();
}
break;
case Type.UnaryExp:
switch(_toktype)
{
default:
break;
case Token.Minus:
return -children[0].evaluate();
case Token.Plus:
return children[0].evaluate();
case Token.Exclamation:
return !children[0].evaluate();
case Token.Tilde:
return ~children[0].evaluate();
}
break;
case Type.EmptyExp:
break;
case Type.BinaryExp:
long v1 = children[0].evaluate();
long v2 = children[1].evaluate();
switch(_toktype)
{
case Token.Asterisk: return v1 * v2;
case Token.Div: return v1 / v2;
case Token.Mod: return v1 % v2;
case Token.Plus: return v1 + v2;
case Token.Minus: return v1 - v2;
case Token.Shl: return v1 << v2;
case Token.Shr: return v1 >> v2;
case Token.LessThan: return v1 < v2;
case Token.LessEq: return v1 <= v2;
case Token.GreaterThan: return v1 > v2;
case Token.GreaterEq: return v1 >= v2;
case Token.Equal: return v1 == v2;
case Token.Unequal: return v1 != v2;
case Token.Ampersand: return v1 & v2;
case Token.Xor: return v1 ^ v2;
case Token.Or: return v1 | v2;
case Token.AmpAmpersand: return v1 && v2;
case Token.OrOr: return v1 || v2;
case Token.Comma: return /*v1,*/ v2;
case Token.Tilde:
case Token.Unordered:
case Token.UnordGreater:
case Token.UnordGreaterEq:
case Token.UnordLess:
case Token.UnordLessEq:
case Token.UnordEq:
case Token.LessGreater:
case Token.LessEqGreater:
default:
break;
}
break;
case Type.CondExp:
return children[0].evaluate() ? children[1].evaluate() : children[2].evaluate();
}
ToStringData tsd;
throwException("cannot evaluate " ~ toString(tsd));
return 0;
}
}
/********************************* Statement Parser ***************************/
class Statement : AST
{
int _toktype;
// toktype == Token.Identifier means Declaration statement
// toktype == Token.Number means Expression statement
this(int toktype, AST child1 = null, AST child2 = null, AST child3 = null, AST child4 = null)
{
super(Type.Statement);
_toktype = toktype;
if(child1)
addChild(child1);
if(child2)
addChild(child2);
if(child3)
addChild(child3);
if(child4)
addChild(child4);
}
static Statement parseStatement(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
Statement stmt;
try
{
L_reparse:
int type = tokIt.type;
switch (type)
{
case Token.Struct:
case Token.Class:
case Token.Union:
case Token.Enum:
case Token.Interface:
Declaration decl = Declaration.parseDeclaration(tokIt, IdentPolicy.MultipleOptional, true);
stmt = new Statement(type, decl);
break;
case Token.Typedef:
case Token.Const:
case Token.Extern:
case Token.Static:
Declaration decl = Declaration.parseDeclaration(tokIt, IdentPolicy.MultipleMandantory, true);
stmt = new Statement(type, decl);
break;
case Token.Identifier:
if(tokIt[1].type == Token.Colon)
{
// label not a statement, just skip and reparse
nextToken(tokIt);
nextToken(tokIt);
goto L_reparse;
}
if(Declaration.guessTypeDecl(tokIt))
{
Declaration decl = Declaration.parseDeclaration(tokIt, IdentPolicy.MultipleMandantory, true);
stmt = new Statement(Token.Identifier, decl);
}
else
{
Expression expr = Expression.parseFullExpression(tokIt);
stmt = new Statement(Token.Number, expr);
checkToken(tokIt, Token.Semicolon);
}
break;
case Token.BraceR:
// though this is invalid, we handle it as an empty statment being followed by ';'
stmt = new Statement(Token.BraceR);
break;
case Token.BraceL:
nextToken(tokIt);
stmt = new Statement(Token.BraceL);
while(tokIt.type != Token.BraceR)
{
Statement s = parseStatement(tokIt);
stmt.addChild(s);
}
nextToken(tokIt);
break;
case Token.Version:
case Token.Static_if:
case Token.If:
nextToken(tokIt);
checkToken(tokIt, Token.ParenL);
Expression expr = Expression.parseFullExpression(tokIt);
checkToken(tokIt, Token.ParenR);
Statement ifstmt = parseStatement(tokIt);
stmt = new Statement(type, expr, ifstmt);
if(tokIt.type == Token.Else)
{
nextToken(tokIt);
Statement elsestmt = parseStatement(tokIt);
stmt.addChild(elsestmt);
}
break;
case Token.Default:
// treat as empty statement, though it should be a label
nextToken(tokIt);
checkToken(tokIt, Token.Colon);
stmt = new Statement(type);
break;
case Token.Case:
// treat as statement, though it should be a label
nextToken(tokIt);
Expression expr = Expression.parseFullExpression(tokIt);
checkToken(tokIt, Token.Colon);
stmt = new Statement(type, expr);
break;
case Token.Switch:
case Token.While:
nextToken(tokIt);
checkToken(tokIt, Token.ParenL);
Expression expr = Expression.parseFullExpression(tokIt);
checkToken(tokIt, Token.ParenR);
Statement bodystmt = parseStatement(tokIt);
stmt = new Statement(type, expr, bodystmt);
break;
case Token.Do:
nextToken(tokIt);
Statement bodystmt = parseStatement(tokIt);
checkToken(tokIt, Token.While);
checkToken(tokIt, Token.ParenL);
Expression expr = Expression.parseFullExpression(tokIt);
checkToken(tokIt, Token.ParenR);
checkToken(tokIt, Token.Semicolon);
stmt = new Statement(type, bodystmt, expr);
break;
case Token.For:
nextToken(tokIt);
checkToken(tokIt, Token.ParenL);
Statement s1 = parseStatement(tokIt);
Statement s2 = parseStatement(tokIt);
Expression expr;
if(tokIt.type != Token.ParenR)
expr = Expression.parseFullExpression(tokIt);
else
{
expr = new Expression(Type.EmptyExp, Token.Empty);
expr.start = expr.end = tokIt;
}
checkToken(tokIt, Token.ParenR);
Statement bodystmt = parseStatement(tokIt);
stmt = new Statement(type, s1, s2, expr, bodystmt);
break;
case Token.Return:
nextToken(tokIt);
stmt = new Statement(type);
if(tokIt.type != Token.Semicolon)
{
Expression expr = Expression.parseFullExpression(tokIt);
stmt.addChild(expr);
}
checkToken(tokIt, Token.Semicolon);
break;
case Token.Continue:
case Token.Break:
nextToken(tokIt);
goto case;
case Token.Semicolon:
checkToken(tokIt, Token.Semicolon);
stmt = new Statement(type);
break;
case Token.Goto:
nextToken(tokIt);
checkToken(tokIt, Token.Identifier);
checkToken(tokIt, Token.Semicolon);
stmt = new Statement(type);
break;
case Token.__Asm:
stmt = new Statement(type);
skipAsmStatement(tokIt);
break;
default:
Expression expr = Expression.parseFullExpression(tokIt);
stmt = new Statement(Token.Number, expr);
checkToken(tokIt, Token.Semicolon);
break;
}
}
catch(Exception e)
{
recoverFromSyntaxError(e, tokIt);
stmt = new Statement(Token.Semicolon); // empty statement
}
stmt.start = start;
stmt.end = tokIt;
return stmt;
}
static void skipAsmStatement(ref TokenIterator tokIt)
{
nextToken(tokIt);
if (tokIt.type == Token.BraceL)
{
nextToken(tokIt);
while(!tokIt.atEnd() && tokIt.type != Token.BraceR)
nextToken(tokIt);
checkToken(tokIt, Token.BraceR);
}
else
{
while(!tokIt.atEnd() && tokIt.type != Token.BraceR && tokIt.type != Token.__Asm)
nextToken(tokIt);
}
}
///////////////////////////////////////////////////////////////////////
override Statement clone()
{
Statement stmt = new Statement(_toktype);
cloneChildren(stmt);
return stmt;
}
override TokenIterator defaultInsertStartTokenPosition()
{
TokenIterator it = start;
if(_toktype == Token.BraceL)
if(it != end && it.type == Token.BraceL)
it.advance();
return it;
}
override TokenIterator defaultInsertEndTokenPosition()
{
TokenIterator it = end;
if(_toktype == Token.BraceL)
if(it != start && it[-1].type == Token.BraceR)
it.retreat();
return it;
}
}
/********************************* Declaration Parser ***************************/
class DeclType : AST
{
enum
{
Basic,
Enum,
Class,
Template,
CtorDtor,
Elipsis,
Namespace,
}
this(int dtype, string ident)
{
super(Type.TypeDeclaration);
_dtype = dtype;
_ident = ident;
}
int _dtype;
string _ident;
override TokenIterator defaultInsertStartTokenPosition()
{
if(_dtype == Class)
{
for(TokenIterator it = start; !it.atEnd() && it != end; ++it)
if(it.type == Token.BraceL)
return it + 1;
}
return super.defaultInsertStartTokenPosition();
}
override TokenIterator defaultInsertEndTokenPosition()
{
if(_dtype == Class)
{
TokenIterator it = end;
if(it != start && it[-1].type == Token.BraceR)
return it - 1;
}
return super.defaultInsertEndTokenPosition();
}
bool isTypedef()
{
for(TokenIterator tokIt = start; tokIt != end; ++tokIt)
if(tokIt.type == Token.Typedef)
return true;
return false;
}
TokenIterator mainTypeIterator()
{
TokenIterator tokIt;
for(tokIt = start; tokIt != end; ++tokIt)
if(!isTypeModifier(tokIt.text))
break;
return tokIt;
}
override string toString(ref ToStringData tsd)
{
string txt;
switch(_dtype)
{
case Basic:
txt = _ident;
break;
case Enum:
if(tsd.addEnumPrefix)
txt = "enum ";
txt ~= _ident;
break;
case Class:
if(tsd.addClassPrefix)
txt = "class ";
txt ~= _ident;
break;
case Template:
string args;
for(ASTIterator it = children.begin(); !it.atEnd(); ++it)
{
if(args.length)
args ~= ", ";
args ~= it.toString(tsd);
}
txt ~= _ident ~ "<" ~ args ~ ">";
break;
case CtorDtor:
break;
case Elipsis:
txt = "...";
break;
case Namespace:
for(ASTIterator it = children.begin(); !it.atEnd(); ++it)
{
if(txt.length)
txt ~= "::";
txt ~= it.toString(tsd);
}
break;
default:
assume(0);
}
return txt;
}
override DeclType clone()
{
DeclType dtype = new DeclType(_dtype, _ident);
cloneChildren(dtype);
return dtype;
}
//////////////////////////////////////////////////////////////////////////////
static bool isBasicType(string ident)
{
switch(ident)
{
case "void":
case "bool":
case "char":
case "int":
case "long":
case "short":
case "signed":
case "unsigned":
case "float":
case "double":
case "_Complex":
case "__int64":
case "_int64":
case "INT32":
case "UINT32":
case "wchar_t":
case "__auto":
case "__enum":
return true;
default:
return false;
}
}
static bool isCallingType(string ident)
{
switch(ident)
{
case "__cdecl":
case "__pascal":
case "__stdcall":
case "__near":
case "__far":
case "__inline":
case "__ss":
case "__naked":
case "__noexpr": // added by pp4d to avoid interpretation of single modifier as expression
return true;
default:
return false;
}
}
static bool isMutabilityModifier(string ident)
{
switch(ident)
{
case "const":
case "volatile":
return true;
default:
return false;
}
}
static bool isPersistentTypeModifier(string ident)
{
switch(ident)
{
case "typedef":
case "static":
case "STATIC": // used for private functions
return true;
default:
return false;
}
}
static bool isTypeModifier(string ident)
{
switch(ident)
{
case "register":
case "virtual":
case "extern":
case "inline":
case "__declspec":
case "CEXTERN":
return true;
default:
return isPersistentTypeModifier(ident)
|| isCallingType(ident)
|| isMutabilityModifier(ident);
}
}
static bool isProtection(string text)
{
switch(text)
{
case "public":
case "private":
case "protected":
return true;
default:
return false;
}
}
static void skipModifiers(ref TokenIterator tokIt)
{
while(isTypeModifier(tokIt.text))
{
bool isExtern = tokIt.type == Token.Extern;
bool isDeclspec = tokIt.text == "__declspec";
nextToken(tokIt);
if(isExtern && tokIt.type == Token.String)
nextToken(tokIt);
if(isDeclspec && tokIt.type == Token.ParenL)
advanceToClosingBracket(tokIt);
}
}
}
class DeclVar : AST
{
this(string ident, Expression init = null)
{
super(Type.EnumDeclaration);
_ident = ident;
if(init)
addChild(init);
}
this(Expression vardecl, Expression init = null)
{
super(Type.VarDeclaration);
if(vardecl)
{
addChild(vardecl);
// drill into vardecl to find identifier
if(auto id = findIdentifier(vardecl))
_ident = getIdentifier(id);
}
if(init)
addChild(init);
}
override string toString(ref ToStringData tsd)
{
bool wasInDeclarator = tsd.inDeclarator;
scope(exit) tsd.inDeclarator = wasInDeclarator;
tsd.inDeclarator = true;
string txt;
ASTIterator it;
if(children)
it = children.begin();
if(_type == Type.EnumDeclaration)
{
txt = _ident;
}
else
{
if(children && !it.atEnd())
{
txt = it.toString(tsd);
it.advance();
}
}
if(tsd.addArgumentDefaults && children && !it.atEnd())
if(cast(Expression) *it) // skip function body
txt ~= " = " ~ it.toString(tsd);
return txt;
}
override DeclVar clone()
{
DeclVar var = _type == Type.EnumDeclaration ? new DeclVar(_ident) : new DeclVar(cast(Expression) null);
cloneChildren(var);
return var;
}
string _ident;
}
class DeclGroup : AST
{
this()
{
super(Type.DeclarationGroup);
}
override DeclGroup clone()
{
DeclGroup grp = new DeclGroup;
cloneChildren(grp);
return grp;
}
override TokenIterator defaultInsertStartTokenPosition()
{
TokenIterator it = start;
if(it != end && it.type == Token.BraceL)
it.advance();
return it;
}
override TokenIterator defaultInsertEndTokenPosition()
{
TokenIterator it = end;
if(it != start && it[-1].type == Token.BraceR)
it.retreat();
return it;
}
}
class DeclConditional : AST
{
this()
{
super(Type.ConditionalDeclaration);
}
override DeclConditional clone()
{
DeclConditional cond = new DeclConditional;
cloneChildren(cond);
return cond;
}
}
class CtorInitializer : AST
{
this()
{
super(Type.CtorInitializer);
}
override CtorInitializer clone()
{
CtorInitializer ctor = new CtorInitializer;
cloneChildren(ctor);
return ctor;
}
}
class CtorInitializers : AST
{
this()
{
super(Type.CtorInitializers);
}
override CtorInitializers clone()
{
CtorInitializers ctors = new CtorInitializers;
cloneChildren(ctors);
return ctors;
}
}
class Declaration : AST
{
this(DeclType decltype)
{
super(Type.Declaration);
if(decltype)
addChild(decltype);
}
static DeclVar parseEnumValue(ref TokenIterator tokIt, string enumName)
{
TokenIterator start = tokIt;
string ident = tokIt.text;
checkToken(tokIt, Token.Identifier);
Expression init;
if(tokIt.type == Token.Assign)
{
nextToken(tokIt);
init = Expression.parseCondExp(tokIt);
}
DeclVar var = new DeclVar(ident, init);
var.start = start;
var.end = tokIt;
return var;
}
static DeclType parseEnum(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
nextToken(tokIt);
string ident;
if (tokIt.type == Token.Identifier)
{
ident = tokIt.text;
nextToken(tokIt);
}
DeclType dtype = new DeclType(DeclType.Enum, ident);
if (tokIt.type == Token.BraceL)
{
nextToken(tokIt);
while(tokIt.type != Token.BraceR)
{
DeclVar var = parseEnumValue(tokIt, ident);
dtype.addChild(var);
if(tokIt.type == Token.Comma)
nextToken(tokIt);
else if(tokIt.type != Token.BraceR)
throwException("unexpected " ~ tokIt.text ~ " in enum declaration");
}
nextToken(tokIt);
}
dtype.start = start;
dtype.end = tokIt;
return dtype;
}
static int isCtorDtor(ref TokenIterator tokIt, ref bool isDtor, string className)
{
isDtor = false;
int off = 0;
if(tokIt.text == "virtual") // allow virtual dtor
off = 1;
if(className.length == 0)
{
if(tokIt[off].type != Token.Identifier || tokIt[off+1].type != Token.DoubleColon)
return 0;
className = tokIt.text;
off += 2;
}
if(tokIt[off].text == className && tokIt[off+1].type == Token.ParenL)
return off + 1;
if(tokIt[off].type == Token.Tilde && tokIt[off+1].text == className && tokIt[off+2].type == Token.ParenL)
{
isDtor = true;
return off + 2;
}
return 0;
}
static CtorInitializer parseCtorInitializer(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
CtorInitializer ini = new CtorInitializer;
checkToken(tokIt, Token.Identifier);
checkToken(tokIt, Token.ParenL);
ini.parseArguments(tokIt, Token.ParenR);
checkToken(tokIt, Token.ParenR);
ini.start = start;
ini.end = tokIt;
return ini;
}
static CtorInitializers parseCtorInitializers(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
checkToken(tokIt, Token.Colon);
CtorInitializers inis = new CtorInitializers;
inis.addChild(parseCtorInitializer(tokIt));
while(tokIt.type == Token.Comma)
{
nextToken(tokIt);
inis.addChild(parseCtorInitializer(tokIt));
}
inis.start = start;
inis.end = tokIt;
return inis;
}
static Declaration parseCtorDtor(ref TokenIterator tokIt, int len, bool isDtor)
{
TokenIterator start = tokIt;
tokIt += len;
string ident = tokIt[-1].text;
checkToken(tokIt, Token.ParenL);
Expression e = new Expression(Type.PrimaryExp, isDtor ? Token.Tilde : Token.This);
e.start = start;
e.end = tokIt - 1;
e = new Expression(Type.PostExp, Token.ParenL, e);
e.parseDeclArguments(tokIt, Token.ParenR);
checkToken(tokIt, Token.ParenR);
e.start = start;
e.end = tokIt;
DeclType decltype = new DeclType(DeclType.CtorDtor, ident);
decltype.start = start;
decltype.end = start;
Declaration decl = new Declaration(decltype);
DeclVar vdecl = new DeclVar(e);
vdecl.start = start;
vdecl.end = tokIt;
decl.addChild(vdecl);
skipThrow(tokIt);
if(!isDtor && tokIt.type == Token.Colon)
{
decl.addChild(parseCtorInitializers(tokIt));
}
if(tokIt.type == Token.__In || tokIt.type == Token.__Out ||
tokIt.type == Token.__Body || tokIt.type == Token.BraceL)
{
Statement stmt = parseFunctionBody(tokIt);
decl.addChild(stmt);
}
else
checkToken(tokIt, Token.Semicolon);
decl.start = start;
decl.end = tokIt;
return decl;
}
static DeclType parseStruct(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
nextToken(tokIt);
DeclType.skipModifiers(tokIt);
string ident;
if (tokIt.type == Token.Identifier)
{
ident = tokIt.text;
nextToken(tokIt);
if (tokIt.type == Token.Colon)
{
nextToken(tokIt);
if (DeclType.isProtection(tokIt.text))
nextToken(tokIt);
string baseclass = tokIt.text;
checkToken(tokIt, Token.Identifier);
addInheritence(baseclass, ident);
// multiple inheritance not supported
}
}
DeclType decl = new DeclType(DeclType.Class, ident);
if (tokIt.type == Token.BraceL)
{
decl.children = new ASTList; // ensure list exists, albeit empty
nextToken(tokIt);
decl.parseDeclarations(tokIt, ident);
checkToken(tokIt, Token.BraceR);
}
decl.start = start;
decl.end = tokIt;
return decl;
}
static bool guessTypeDecl(TokenIterator tokIt)
{
if(tokIt.text == "typename")
tokIt.advance();
DeclType.skipModifiers(tokIt);
// declaration always starts with an identifier (including basic types)
if(tokIt.type != Token.Identifier)
return false;
tokIt.advance();
while(tokIt.type == Token.DoubleColon)
{
tokIt.advance();
if (tokIt.type != Token.Identifier)
return false;
tokIt.advance();
}
if(tokIt.type == Token.Identifier || tokIt.type == Token.Asterisk ||
DeclType.isTypeModifier(tokIt.text))
return true;
return false;
}
static DeclType parseTypeDeclaration(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
DeclType decl;
if(tokIt.text == "typename")
tokIt.advance();
DeclType.skipModifiers(tokIt);
switch (tokIt.type)
{
case Token.Enum:
decl = parseEnum(tokIt);
break;
case Token.Struct:
case Token.Class:
case Token.Union:
case Token.Interface:
decl = parseStruct(tokIt);
break;
default:
string ident = tokIt.text;
if(DeclType.isBasicType(ident))
{
nextToken(tokIt);
while(DeclType.isBasicType(tokIt.text))
nextToken(tokIt);
decl = new DeclType(DeclType.Basic, ident);
}
else
{
checkToken(tokIt, Token.Identifier);
if(tokIt.type == Token.LessThan)
{
nextToken(tokIt);
decl = new DeclType(DeclType.Template, ident);
decl.parseDeclArguments(tokIt, Token.GreaterThan);
checkToken(tokIt, Token.GreaterThan);
}
else
decl = new DeclType(DeclType.Class, ident);
if(tokIt.type == Token.DoubleColon)
{
auto ldecl = decl;
ldecl.start = start;
ldecl.end = tokIt;
tokIt.advance();
auto rdecl = parseTypeDeclaration(tokIt);
decl = new DeclType(DeclType.Namespace, decl._ident ~ "." ~ rdecl._ident);
decl.addChild(ldecl);
decl.addChild(rdecl);
}
}
break;
}
while(DeclType.isCallingType(tokIt.text) || DeclType.isMutabilityModifier(tokIt.text))
nextToken(tokIt);
decl.start = start;
decl.end = tokIt;
return decl;
}
static DeclVar parseDeclVar(ref TokenIterator tokIt, IdentPolicy idpolicy, bool declstmt)
{
TokenIterator start = tokIt;
Expression expr = Expression.parseDeclExp(tokIt, idpolicy, declstmt);
DeclVar vdecl = new DeclVar(expr);
if(tokIt.type == Token.Assign)
{
nextToken(tokIt);
Expression init = Expression.parseAssignExp(tokIt);
vdecl.addChild(init);
}
vdecl.start = start;
vdecl.end = tokIt;
return vdecl;
}
static DeclGroup parseDeclarationGroup(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
DeclGroup grp = new DeclGroup;
if(tokIt.type == Token.Version || tokIt.type == Token.Static_if)
{
grp.addChild(Declaration.parseStaticIfVersion(tokIt));
}
else if(tokIt.type == Token.BraceL)
{
nextToken(tokIt);
grp.parseDeclarations(tokIt);
checkToken(tokIt, Token.BraceR);
}
else
{
nextToken(tokIt);
Declaration decl = parseDeclaration(tokIt);
grp.addChild(grp);
}
grp.start = start;
grp.end = tokIt;
return grp;
}
static DeclConditional parseStaticIfVersion(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
DeclConditional decl;
switch(start.type)
{
case Token.Version:
case Token.Static_if:
nextToken(tokIt);
checkToken(tokIt, Token.ParenL);
Expression expr = Expression.parseFullExpression(tokIt);
checkToken(tokIt, Token.ParenR);
decl = new DeclConditional;
decl.addChild(expr);
DeclGroup dif = parseDeclarationGroup(tokIt);
decl.addChild(dif);
if(tokIt.type == Token.Else)
{
nextToken(tokIt);
DeclGroup delse = parseDeclarationGroup(tokIt);
decl.addChild(delse);
}
break;
default:
throwException(start.lineno, "unexpected " ~ start.text);
}
decl.start = start;
decl.end = tokIt;
return decl;
}
static Declaration parseTemplateDeclaration(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
DeclType decltype = new DeclType(DeclType.Template, "template");
checkToken(tokIt, Token.Template);
if(!tokIt.atEnd() && tokIt.type == Token.LessGreater) // special case for <>
{
tokIt.text = "<";
tokIt.type = Token.LessThan;
tokIt.insertAfter(createToken("", ">", Token.GreaterThan, tokIt.lineno));
checkToken(tokIt, Token.LessThan);
checkToken(tokIt, Token.GreaterThan);
}
else
{
checkToken(tokIt, Token.LessThan);
if(!tokIt.atEnd() && tokIt.type != Token.GreaterThan)
{
decltype.addChild(parseTypeDeclaration(tokIt));
while(!tokIt.atEnd() && tokIt.type == Token.Comma)
{
tokIt.advance();
decltype.addChild(parseTypeDeclaration(tokIt));
}
}
checkToken(tokIt, Token.GreaterThan);
}
decltype.start = start;
decltype.end = tokIt;
Declaration decl = new Declaration(decltype);
decl.addChild(parseDeclaration(tokIt));
decl.start = start;
decl.end = tokIt;
return decl;
}
static void skipThrow(ref TokenIterator tokIt)
{
if(tokIt.text == "throw")
{
nextToken(tokIt);
if(tokIt.type == Token.ParenL)
advanceToClosingBracket(tokIt);
}
}
static Declaration parseDeclaration(ref TokenIterator tokIt,
IdentPolicy idpolicy = IdentPolicy.MultipleOptional, bool declstmt = false)
{
if(tokIt.type == Token.Template)
return parseTemplateDeclaration(tokIt);
TokenIterator start = tokIt;
DeclType decltype = parseTypeDeclaration(tokIt);
Declaration decl = new Declaration(decltype);
if (tokIt.type != Token.Semicolon)
{
while(!tokIt.atEnd())
{
DeclVar vdecl = parseDeclVar(tokIt, idpolicy, declstmt);
decl.addChild(vdecl);
if(decltype.isTypedef())
addTypedef(decltype, vdecl);
if(idpolicy == IdentPolicy.SingleOptional || idpolicy == IdentPolicy.SingleMandantory ||
idpolicy == IdentPolicy.Prohibited)
goto L_eodecl;
if(DeclType.isMutabilityModifier(tokIt.text))
nextToken(tokIt);
skipThrow(tokIt);
if(tokIt.type == Token.__In || tokIt.type == Token.__Out ||
tokIt.type == Token.__Body || tokIt.type == Token.BraceL)
{
Statement stmt = parseFunctionBody(tokIt);
decl.addChild(stmt);
goto L_eodecl;
}
if(tokIt.type != Token.Comma)
break;
nextToken(tokIt);
}
}
checkToken(tokIt, Token.Semicolon);
L_eodecl:
decl.start = start;
decl.end = tokIt;
return decl;
}
static Statement parseFunctionBody(ref TokenIterator tokIt)
{
TokenIterator start = tokIt;
Statement stmt = new Statement(Token.__Body);
while(!tokIt.atEnd())
{
int toktype = tokIt.type;
if(tokIt.type == Token.__Out)
{
nextToken(tokIt);
checkToken(tokIt, Token.ParenL);
checkToken(tokIt, Token.Identifier);
checkToken(tokIt, Token.ParenR);
Statement s = Statement.parseStatement(tokIt);
stmt.addChild(s);
}
else if(tokIt.type == Token.__In || tokIt.type == Token.__Body)
{
nextToken(tokIt);
Statement s = Statement.parseStatement(tokIt);
stmt.addChild(s);
if(toktype == Token.__Body)
break;
}
else if (tokIt.type == Token.BraceL)
{
Statement s = Statement.parseStatement(tokIt);
stmt.addChild(s);
break;
}
else
throwException(tokIt.lineno, "function body expected");
}
L_eodecl:
stmt.start = start;
stmt.end = tokIt;
return stmt;
}
///////////////////////////////////////////////////////////////////////////////
override string toString(ref ToStringData tsd)
{
string txt;
ASTIterator it = children.begin();
txt ~= it.toString(tsd);
string prefix = txt.length > 0 ? " " : "";
for(it.advance(); !it.atEnd(); ++it)
{
if(!tsd.addFunctionBody && (it._type == Type.Statement || it._type == Type.CtorInitializers))
continue;
txt ~= prefix ~ it.toString(tsd);
prefix = ", ";
}
return txt;
}
override Declaration clone()
{
Declaration decl = new Declaration(null);
cloneChildren(decl);
return decl;
}
}
///////////////////////////////////////////////////////////////////////////////
// tree manipulations
///////////////////////////////////////////////////////////////////////////////
int expressionType(Expression expr)
{
assume(expr);
return expr._toktype;
}
int expressionType(AST ast)
{
Expression expr = cast(Expression) ast;
return expressionType(expr);
}
enum DeclClassification
{
None,
FuncDeclaration,
AbstractFuncDeclaration,
FuncDefinition,
VarDeclaration,
VarDefinition,
}
DeclClassification classifyDeclaration(AST ast)
{
if(Declaration decl = cast(Declaration) ast)
{
if(decl.children.count() >= 2)
{
DeclType dtype = cast(DeclType) decl.children[0];
DeclVar dvar = cast(DeclVar) decl.children[1];
if(dtype && dvar)
{
ASTIterator it = dvar.children.begin();
if(!it.atEnd() && isFunctionDeclExpression(*it))
{
for(it.advance(); !it.atEnd(); ++it)
if(expressionType(*it) == Token.Number) // = 0?
return DeclClassification.AbstractFuncDeclaration;
for(it = decl.children.begin(); !it.atEnd(); ++it)
if(it._type == AST.Type.Statement)
return DeclClassification.FuncDefinition;
return DeclClassification.FuncDeclaration;
}
else if(!it.atEnd())
{
for(it.advance(); !it.atEnd(); ++it)
if(cast(Expression)*it)
return DeclClassification.VarDefinition;
return DeclClassification.VarDeclaration;
}
}
}
}
return DeclClassification.None;
}
bool isFunctionDeclExpression(AST ast)
{
while(ast._type == AST.Type.UnaryExp)
ast = ast.children[0];
if (ast._type != AST.Type.PostExp || expressionType(ast) != Token.ParenL)
return false;
// check arguments: if these are not declarations, it's a var initializer
if(!ast.children || ast.children.count() <= 1)
return true;
return (cast(Declaration) ast.children[1]) !is null; // check first argument
}
bool isFunctionDeclaration(AST ast)
{
DeclClassification type = classifyDeclaration(ast);
return type == DeclClassification.FuncDeclaration;
}
bool isFunctionDefinition(AST ast)
{
DeclClassification type = classifyDeclaration(ast);
return type == DeclClassification.FuncDefinition;
}
bool isVarDeclaration(AST ast)
{
DeclClassification type = classifyDeclaration(ast);
return type == DeclClassification.VarDeclaration;
}
bool isVarDefinition(AST ast)
{
DeclClassification type = classifyDeclaration(ast);
return type == DeclClassification.VarDefinition;
}
DeclType isClassDefinition(AST ast)
{
if(Declaration decl = cast(Declaration) ast)
{
if(decl.children.count() >= 1)
{
DeclType dtype = cast(DeclType) decl.children[0];
if(dtype._dtype == DeclType.Class && dtype.children)
return dtype;
}
}
return null;
}
string getIdentifier(AST ast)
{
for(TokenIterator tokIt = ast.start; tokIt != ast.end; ++tokIt)
if(tokIt.type == Token.Identifier)
return tokIt.text;
return null;
}
AST findIdentifier(AST ast)
{
if(ast._type == AST.Type.PrimaryExp)
{
switch(ast.start.type)
{
case Token.Identifier:
case Token.Operator:
case Token.Tilde:
case Token.This:
return ast;
default:
break;
}
}
if(ast.children)
for(ASTIterator it = ast.children.begin(); !it.atEnd(); ++it)
if(AST ident = findIdentifier(*it))
return ident;
return null;
}
debug
void dumpIdentifier(Declaration decl)
{
import std.stdio;
string txt;
ASTIterator it = decl.children.begin();
DeclType decltype = cast(DeclType) *it;
assume(decltype);
ToStringData tsd;
tsd.noIdentifierInPrototype = true;
txt ~= decltype.toString(tsd);
string prefix = " ";
for(it.advance(); !it.atEnd(); ++it)
{
DeclVar declvar = cast(DeclVar) *it;
assume(declvar);
string ident;
if(AST ast = findIdentifier(declvar.children[0]))
ident = tokensToIdentifier(ast.start, ast.end);
txt ~= prefix ~ ident;
prefix = ", ";
}
writefln(txt ~ ";");
}
void iterateTopLevelDeclarations(AST ast, void delegate(Declaration) apply)
{
if(!ast.children)
return;
for(ASTIterator it = ast.children.begin(); !it.atEnd(); ++it)
{
switch(it._type)
{
case AST.Type.ConditionalDeclaration:
// first child is expression
if(it.children.count() >= 2)
iterateTopLevelDeclarations(it.children[1], apply);
if(it.children.count() >= 3)
iterateTopLevelDeclarations(it.children[2], apply);
break;
case AST.Type.DeclarationGroup:
iterateTopLevelDeclarations(*it, apply);
break;
case AST.Type.PrimaryExp:
if(it.start.type == Token.Mixin)
break;
// TODO?
break;
case AST.Type.Protection:
break;
default:
if(Declaration decl = cast(Declaration) *it)
apply(decl);
else
throwException(it.start.lineno, "declaration expected");
}
}
}
bool copyDefaultArguments(Declaration from, Declaration to)
{
if(!from.children || from.children.count < 2 || !to.children || to.children.count < 2)
return false;
DeclVar fromVar = cast(DeclVar) from.children[1];
DeclVar toVar = cast(DeclVar) to.children[1];
if(!fromVar || !toVar)
return false;
// assume post expression ParenL for arguments
if(!fromVar.children || fromVar.children.count < 1 || !toVar.children || toVar.children.count < 1)
return false;
Expression fromExpr = cast(Expression) fromVar.children[0];
Expression toExpr = cast(Expression) toVar.children[0];
while(fromExpr && fromExpr._type == AST.Type.UnaryExp && toExpr && toExpr._type == AST.Type.UnaryExp)
{
fromExpr = cast(Expression) fromExpr.children[0];
toExpr = cast(Expression) toExpr.children[0];
}
if(!fromExpr || fromExpr._type != AST.Type.PostExp || fromExpr._toktype != Token.ParenL)
return false;
if(!toExpr || toExpr._type != AST.Type.PostExp || toExpr._toktype != Token.ParenL)
return false;
ASTIterator fromIt = fromExpr.children.begin() + 1;
ASTIterator toIt = toExpr.children.begin() + 1;
while(!fromIt.atEnd() && !toIt.atEnd())
{
Declaration fromDecl = cast(Declaration) *fromIt;
Declaration toDecl = cast(Declaration) *toIt;
if(!fromDecl || !toDecl)
break;
if(!fromDecl.children || fromDecl.children.count < 2 || !toDecl.children || toDecl.children.count < 2)
break;
DeclVar fromArg = cast(DeclVar) fromDecl.children[1];
DeclVar toArg = cast(DeclVar) toDecl.children[1];
if(!fromArg || !toArg)
break;
if(fromArg.children && fromArg.children.count > 1 && toArg.children && toArg.children.count == 1)
{
Expression fromInit = cast(Expression) fromArg.children[1];
Expression toInit = fromInit.clone();
TokenList cloneList = toInit.cloneTokens();
toArg.insertChildBefore(toArg.children.end(), toInit, cloneList);
// need to insert "=" here
TokenList asgnList = copyTokenList(fromInit.start - 1, fromInit.start, true);
toArg.insertTokenListBefore(toInit, asgnList);
}
fromIt.advance();
toIt.advance();
}
return (fromIt.atEnd() && toIt.atEnd());
}
///////////////////////////////////////////////////////////////////////
AST testAST(string txt)
{
bool oldRecover = tryRecover;
scope(exit) tryRecover = oldRecover;
tryRecover = false;
TokenList tokenList = scanText(txt);
AST ast = new AST(AST.Type.Module);
TokenIterator tokIt = tokenList.begin();
ast.parseModule(tokIt);
return ast;
}
unittest
{
string txt = "X::~X() {}";
AST ast = testAST(txt);
Declaration decl = cast(Declaration) ast.children[0];
assert(decl);
assert(isFunctionDefinition(decl));
ToStringData tsd;
tsd.noIdentifierInPrototype = true;
string ident = decl.toString(tsd);
assert(ident == "X::~X()");
}
unittest
{
string txt = "X::~X() {}";
AST ast = testAST(txt);
Declaration decl = cast(Declaration) ast.children[0];
assert(decl);
assert(decl.children.count() > 2);
Statement stmt = cast(Statement) decl.children[2];
Statement s2 = stmt.clone();
s2.cloneTokens();
string exp = " {}";
string res = tokenListToString(s2.start, s2.end);
assert(exp == res);
}
unittest
{
string txt = "struct S { int x; } s;";
AST ast = testAST(txt);
Declaration decl = cast(Declaration) ast.children[0];
assert(decl);
assert(decl.children.count() == 2);
DeclType dtype = cast(DeclType) decl.children[0];
assert(dtype);
assert(dtype.children.count() == 1);
dtype.removeToken(dtype.start + 2); // '{'
dtype.removeChild(dtype.children[0]);
dtype.removeToken(dtype.start + 2); // '}'
ast.verify();
string exp = "struct S s;";
string res = tokenListToString(ast.start, ast.end);
assert(exp == res);
}
unittest
{
string txt = "typedef X const*PX;";
AST ast = testAST(txt);
}
unittest
{
string txt = "template<> struct S {};"; // cannot deal with specializations, though
AST ast = testAST(txt);
}
unittest
{
string txt = "typedef void (__noexpr __stdcall *fn)();";
AST ast = testAST(txt);
}
|
D
|
# FIXED
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/source/HL_errata.c
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_errata.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_reg_pbist.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_sys_common.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_hal_stdtypes.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/stdint.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/sys/stdint.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/sys/cdefs.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/sys/_types.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/machine/_types.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/machine/_stdint.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/sys/_stdint.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/stdbool.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_reg_system.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_reg_gio.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_sys_core.h
HALCoGen-TMS570LC43x/source/HL_errata.obj: /home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_sys_pmu.h
/home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/source/HL_errata.c:
/home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_errata.h:
/home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_reg_pbist.h:
/home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_sys_common.h:
/home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_hal_stdtypes.h:
/home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/stdint.h:
/home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/sys/stdint.h:
/home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/sys/cdefs.h:
/home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/sys/_types.h:
/home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/machine/_types.h:
/home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/machine/_stdint.h:
/home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/sys/_stdint.h:
/home/koitt/ti/ccsv8/tools/compiler/ti-cgt-arm_18.1.4.LTS/include/stdbool.h:
/home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_reg_system.h:
/home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_reg_gio.h:
/home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_sys_core.h:
/home/koitt/lwip_demo/HALCoGen_EMAC_Driver_with_lwIP_Demonstration/v00.03.00/TMS570LC43x/HALCoGen-TMS570LC43x/include/HL_sys_pmu.h:
|
D
|
/++
This is a submodule of $(MREF mir, ndslice).
Safety_note:
User-defined iterators $(RED must) care about their safety except bounds checks.
Bounds are checked in ndslice code.
License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
Copyright: Copyright © 2016-, Ilya Yaroshenko
Authors: Ilya Yaroshenko
$(BOOKTABLE $(H2 Definitions),
$(TR $(TH Name) $(TH Description))
$(T2 Slice, N-dimensional slice.)
$(T2 SliceKind, SliceKind of $(LREF Slice) enumeration.)
$(T2 Universal, Alias for $(LREF .SliceKind.universal).)
$(T2 Canonical, Alias for $(LREF .SliceKind.canonical).)
$(T2 Contiguous, Alias for $(LREF .SliceKind.contiguous).)
$(T2 sliced, Creates a slice on top of an iterator, a pointer, or an array's pointer.)
$(T2 slicedField, Creates a slice on top of a field, a random access range, or an array.)
$(T2 slicedNdField, Creates a slice on top of an ndField.)
$(T2 kindOf, Extracts $(LREF SliceKind).)
$(T2 isSlice, Extracts dimension count from a type. Extracts `null` if the template argument is not a `Slice`.)
$(T2 Structure, A tuple of lengths and strides.)
)
Macros:
SUBREF = $(REF_ALTTEXT $(TT $2), $2, mir, ndslice, $1)$(NBSP)
T2=$(TR $(TDNW $(LREF $1)) $(TD $+))
T4=$(TR $(TDNW $(LREF $1)) $(TD $2) $(TD $3) $(TD $4))
STD = $(TD $(SMALL $0))
+/
module mir.ndslice.slice;
import mir.internal.utility : Iota;
import mir.math.common : optmath;
import mir.ndslice.concatenation;
import mir.ndslice.field;
import mir.ndslice.internal;
import mir.ndslice.iterator;
import mir.primitives;
import mir.qualifier;
import mir.utility;
import std.meta;
import std.traits;
public import mir.primitives: DeepElementType;
@optmath:
/++
Checks if type T has asSlice property and its returns a slices.
Aliases itself to a dimension count
+/
template hasAsSlice(T)
{
static if (__traits(hasMember, T, "asSlice"))
enum size_t hasAsSlice = typeof(T.init.asSlice).N;
else
enum size_t hasAsSlice = 0;
}
///
version(mir_test) unittest
{
import mir.series;
static assert(!hasAsSlice!(int[]));
static assert(hasAsSlice!(SeriesMap!(int, string)) == 1);
}
/++
Check if $(LREF toConst) function can be called with type T.
+/
enum isConvertibleToSlice(T) = isSlice!T || isDynamicArray!T || hasAsSlice!T;
///
version(mir_test) unittest
{
import mir.series: SeriesMap;
static assert(isConvertibleToSlice!(immutable int[]));
static assert(isConvertibleToSlice!(string[]));
static assert(isConvertibleToSlice!(SeriesMap!(string, int)));
static assert(isConvertibleToSlice!(Slice!(int*)));
}
/++
Reurns:
Ndslice view in the same data.
See_also: $(LREF isConvertibleToSlice).
+/
auto toSlice(Iterator, size_t N, SliceKind kind)(Slice!(Iterator, N, kind) val)
{
return val;
}
/// ditto
auto toSlice(Iterator, size_t N, SliceKind kind)(const Slice!(Iterator, N, kind) val)
{
return val[];
}
/// ditto
auto toSlice(Iterator, size_t N, SliceKind kind)(immutable Slice!(Iterator, N, kind) val)
{
return val[];
}
/// ditto
auto toSlice(T)(T[] val)
{
return val.sliced;
}
/// ditto
auto toSlice(T)(T val)
if (hasAsSlice!T)
{
return val.asSlice;
}
///
template toSlices(args...)
{
static if (args.length)
{
alias arg = args[0];
@optmath @property auto ref slc()()
{
return toSlice(arg);
}
alias toSlices = AliasSeq!(slc, toSlices!(args[1..$]));
}
else
alias toSlices = AliasSeq!();
}
///
template isSlice(T)
{
static if (is(T : Slice!(Iterator, N, kind), Iterator, size_t N, SliceKind kind))
enum bool isSlice = true;
else
enum bool isSlice = false;
}
///
@safe pure nothrow @nogc
version(mir_test) unittest
{
alias A = uint[];
alias S = Slice!(int*);
static assert(isSlice!S);
static assert(!isSlice!A);
}
/++
SliceKind of $(LREF Slice).
See_also:
$(SUBREF topology, universal),
$(SUBREF topology, canonical),
$(SUBREF topology, assumeCanonical),
$(SUBREF topology, assumeContiguous).
+/
alias SliceKind = mir_slice_kind;
/// ditto
enum mir_slice_kind
{
/// A slice has strides for all dimensions.
universal,
/// A slice has >=2 dimensions and row dimension is contiguous.
canonical,
/// A slice is a flat contiguous data without strides.
contiguous,
}
/++
Alias for $(LREF .SliceKind.universal).
See_also:
Internal Binary Representation section in $(LREF Slice).
+/
alias Universal = SliceKind.universal;
/++
Alias for $(LREF .SliceKind.canonical).
See_also:
Internal Binary Representation section in $(LREF Slice).
+/
alias Canonical = SliceKind.canonical;
/++
Alias for $(LREF .SliceKind.contiguous).
See_also:
Internal Binary Representation section in $(LREF Slice).
+/
alias Contiguous = SliceKind.contiguous;
/// Extracts $(LREF SliceKind).
enum kindOf(T : Slice!(Iterator, N, kind), Iterator, size_t N, SliceKind kind) = kind;
///
@safe pure nothrow @nogc
version(mir_test) unittest
{
static assert(kindOf!(Slice!(int*, 1, Universal)) == Universal);
}
/// Extracts iterator type from a $(LREF Slice).
alias IteratorOf(T : Slice!(Iterator, N, kind), Iterator, size_t N, SliceKind kind) = Iterator;
private template SkipDimension(size_t dimension, size_t index)
{
static if (index < dimension)
enum SkipDimension = index;
else
static if (index == dimension)
static assert (0, "SkipInex: wrong index");
else
enum SkipDimension = index - 1;
}
/++
Creates an n-dimensional slice-shell over an iterator.
Params:
iterator = An iterator, a pointer, or an array.
lengths = A list of lengths for each dimension
Returns:
n-dimensional slice
+/
auto sliced(size_t N, Iterator)(Iterator iterator, size_t[N] lengths...)
if (!isStaticArray!Iterator && N
&& !is(Iterator : Slice!(_Iterator, _N, kind), _Iterator, size_t _N, SliceKind kind))
{
alias C = ImplicitlyUnqual!(typeof(iterator));
size_t[N] _lengths;
foreach (i; Iota!N)
_lengths[i] = lengths[i];
ptrdiff_t[1] _strides = 0;
static if (isDynamicArray!Iterator)
{
assert(lengthsProduct(_lengths) <= iterator.length,
"array length should be greater or equal to the product of constructed ndslice lengths");
auto ptr = iterator.length ? &iterator[0] : null;
return Slice!(typeof(C.init[0])*, N)(_lengths, ptr);
}
else
{
// break safety
if (false)
{
++iterator;
--iterator;
iterator = iterator + 34;
iterator -= 34;
}
return Slice!(C, N)(_lengths, iterator);
}
}
/// $(LINK2 https://en.wikipedia.org/wiki/Vandermonde_matrix, Vandermonde matrix)
@safe pure nothrow version(mir_test) unittest
{
auto vandermondeMatrix(Slice!(double*) x)
@safe nothrow pure
{
import mir.ndslice.allocation: slice;
auto ret = slice!double(x.length, x.length);
foreach (i; 0 .. x.length)
foreach (j; 0 .. x.length)
ret[i][j] = x[i] ^^ j;
return ret;
}
import mir.ndslice.topology: universal;
auto x = [1.0, 2, 3, 4, 5].sliced;
auto v = vandermondeMatrix(x);
assert(v ==
[[ 1.0, 1, 1, 1, 1],
[ 1.0, 2, 4, 8, 16],
[ 1.0, 3, 9, 27, 81],
[ 1.0, 4, 16, 64, 256],
[ 1.0, 5, 25, 125, 625]]);
}
/// Random access range primitives for slices over user defined types
@safe pure nothrow @nogc version(mir_test) unittest
{
struct MyIota
{
//`[index]` operator overloading
auto opIndex(size_t index) @safe nothrow
{
return index;
}
auto lightConst()() const @property { return MyIota(); }
auto lightImmutable()() immutable @property { return MyIota(); }
}
import mir.ndslice.iterator: FieldIterator;
alias Iterator = FieldIterator!MyIota;
alias S = Slice!(Iterator, 2);
import std.range.primitives;
static assert(hasLength!S);
static assert(hasSlicing!S);
static assert(isRandomAccessRange!S);
auto slice = Iterator().sliced(20, 10);
assert(slice[1, 2] == 12);
auto sCopy = slice.save;
assert(slice[1, 2] == 12);
}
/++
Creates an 1-dimensional slice-shell over an array.
Params:
array = An array.
Returns:
1-dimensional slice
+/
auto sliced(T)(T[] array)
{
return .sliced(array, [array.length]);
}
/// Creates a slice from an array.
@safe pure nothrow version(mir_test) unittest
{
auto slice = new int[10].sliced;
assert(slice.length == 10);
static assert(is(typeof(slice) == Slice!(int*)));
}
/++
Creates an n-dimensional slice-shell over the 1-dimensional input slice.
Params:
slice = slice
lengths = A list of lengths for each dimension.
Returns:
n-dimensional slice
+/
Slice!(Iterator, N, kind)
sliced
(Iterator, size_t N, SliceKind kind)
(Slice!(Iterator, 1, kind) slice, size_t[N] lengths...)
if (N)
{
auto structure = typeof(return)._Structure.init;
structure[0] = lengths;
static if (kind != Contiguous)
{
import mir.ndslice.topology: iota;
structure[1] = structure[0].iota.strides;
}
return typeof(return)(structure, slice._iterator);
}
///
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
auto data = new int[24];
foreach (int i,ref e; data)
e = i;
auto a = data[0..10].sliced(10)[0..6].sliced(2, 3);
auto b = iota!int(10)[0..6].sliced(2, 3);
assert(a == b);
a[] += b;
foreach (int i, e; data[0..6])
assert(e == 2*i);
foreach (int i, e; data[6..$])
assert(e == i+6);
}
/++
Creates an n-dimensional slice-shell over a field.
Params:
field = A field. The length of the
array should be equal to or less then the product of
lengths.
lengths = A list of lengths for each dimension.
Returns:
n-dimensional slice
+/
Slice!(FieldIterator!Field, N)
slicedField(Field, size_t N)(Field field, size_t[N] lengths...)
if (N)
{
static if (hasLength!Field)
assert(lengths.lengthsProduct <= field.length, "Length product should be less or equal to the field length.");
return FieldIterator!Field(0, field).sliced(lengths);
}
///ditto
auto slicedField(Field)(Field field)
if(hasLength!Field)
{
return .slicedField(field, field.length);
}
/// Creates an 1-dimensional slice over a field, array, or random access range.
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
auto slice = 10.iota.slicedField;
assert(slice.length == 10);
}
/++
Creates an n-dimensional slice-shell over an ndField.
Params:
field = A ndField. Lengths should fit into field's shape.
lengths = A list of lengths for each dimension.
Returns:
n-dimensional slice
See_also: $(SUBREF concatenation, concatenation) examples.
+/
Slice!(IndexIterator!(FieldIterator!(ndIotaField!N), ndField), N)
slicedNdField(ndField, size_t N)(ndField field, size_t[N] lengths...)
if (N)
{
static if(hasShape!ndField)
{
auto shape = field.shape;
foreach (i; 0 .. N)
assert(lengths[i] <= shape[i], "Lengths should fit into ndfield's shape.");
}
import mir.ndslice.topology: indexed, ndiota;
return indexed(field, ndiota(lengths));
}
///ditto
auto slicedNdField(ndField)(ndField field)
if(hasShape!ndField)
{
return .slicedNdField(field, field.shape);
}
/++
Combination of coordinate(s) and value.
+/
struct CoordinateValue(T, size_t N = 1)
{
///
size_t[N] index;
///
T value;
///
sizediff_t opCmp()(scope auto ref const typeof(this) rht) const
{
return cmpCoo(this.index, rht.index);
}
}
private sizediff_t cmpCoo(size_t N)(scope const auto ref size_t[N] a, scope const auto ref size_t[N] b)
{
foreach (i; Iota!(0, N))
if (auto d = a[i] - b[i])
return d;
return 0;
}
/++
Presents $(LREF .Slice.structure).
+/
struct Structure(size_t N)
{
///
size_t[N] lengths;
///
sizediff_t[N] strides;
}
/++
Presents an n-dimensional view over a range.
$(H3 Definitions)
In order to change data in a slice using
overloaded operators such as `=`, `+=`, `++`,
a syntactic structure of type
`<slice to change>[<index and interval sequence...>]` must be used.
It is worth noting that just like for regular arrays, operations `a = b`
and `a[] = b` have different meanings.
In the first case, after the operation is carried out, `a` simply points at the same data as `b`
does, and the data which `a` previously pointed at remains unmodified.
Here, `а` and `b` must be of the same type.
In the second case, `a` points at the same data as before,
but the data itself will be changed. In this instance, the number of dimensions of `b`
may be less than the number of dimensions of `а`; and `b` can be a Slice,
a regular multidimensional array, or simply a value (e.g. a number).
In the following table you will find the definitions you might come across
in comments on operator overloading.
$(BOOKTABLE
$(TR $(TH Operator Overloading) $(TH Examples at `N == 3`))
$(TR $(TD An $(B interval) is a part of a sequence of type `i .. j`.)
$(STD `2..$-3`, `0..4`))
$(TR $(TD An $(B index) is a part of a sequence of type `i`.)
$(STD `3`, `$-1`))
$(TR $(TD A $(B partially defined slice) is a sequence composed of
$(B intervals) and $(B indexes) with an overall length strictly less than `N`.)
$(STD `[3]`, `[0..$]`, `[3, 3]`, `[0..$,0..3]`, `[0..$,2]`))
$(TR $(TD A $(B fully defined index) is a sequence
composed only of $(B indexes) with an overall length equal to `N`.)
$(STD `[2,3,1]`))
$(TR $(TD A $(B fully defined slice) is an empty sequence
or a sequence composed of $(B indexes) and at least one
$(B interval) with an overall length equal to `N`.)
$(STD `[]`, `[3..$,0..3,0..$-1]`, `[2,0..$,1]`))
$(TR $(TD An $(B indexed slice) is syntax sugar for $(SUBREF topology, indexed) and $(SUBREF topology, cartesian).)
$(STD `[anNdslice]`, `[$.iota, anNdsliceForCartesian1, $.iota]`))
)
See_also:
$(SUBREF topology, iota).
$(H3 Internal Binary Representation)
Multidimensional Slice is a structure that consists of lengths, strides, and a iterator (pointer).
$(SUBREF topology, FieldIterator) shell is used to wrap fields and random access ranges.
FieldIterator contains a shift of the current initial element of a multidimensional slice
and the field itself.
With the exception of $(MREF mir,ndslice,allocation) module, no functions in this
package move or copy data. The operations are only carried out on lengths, strides,
and pointers. If a slice is defined over a range, only the shift of the initial element
changes instead of the range.
$(H4 Internal Representation for Universal Slices)
Type definition
-------
Slice!(Universal, N, Iterator)
-------
Schema
-------
Slice!(Universal, N, Iterator)
size_t[N] _lengths
sizediff_t[N] _strides
Iterator _iterator
-------
$(H5 Example)
Definitions
-------
import mir.ndslice;
auto a = new double[24];
Slice!(Universal, [3], double*) s = a.sliced(2, 3, 4).universal;
Slice!(Universal, [3], double*) t = s.transposed!(1, 2, 0);
Slice!(Universal, [3], double*) r = t.reversed!1;
-------
Representation
-------
s________________________
lengths[0] ::= 2
lengths[1] ::= 3
lengths[2] ::= 4
strides[0] ::= 12
strides[1] ::= 4
strides[2] ::= 1
iterator ::= &a[0]
t____transposed!(1, 2, 0)
lengths[0] ::= 3
lengths[1] ::= 4
lengths[2] ::= 2
strides[0] ::= 4
strides[1] ::= 1
strides[2] ::= 12
iterator ::= &a[0]
r______________reversed!1
lengths[0] ::= 2
lengths[1] ::= 3
lengths[2] ::= 4
strides[0] ::= 12
strides[1] ::= -4
strides[2] ::= 1
iterator ::= &a[8] // (old_strides[1] * (lengths[1] - 1)) = 8
-------
$(H4 Internal Representation for Canonical Slices)
Type definition
-------
Slice!(Canonical, N, Iterator)
-------
Schema
-------
Slice!(Universal, N, Iterator)
size_t[N] _lengths
sizediff_t[N-1] _strides
Iterator _iterator
-------
$(H4 Internal Representation for Contiguous Slices)
Type definition
-------
Slice!(N, Iterator)
-------
Schema
-------
Slice!(Universal, N, Iterator)
size_t[N] _lengths
sizediff_t[0] _strides
Iterator _iterator
-------
+/
struct mir_slice(Iterator_, size_t N_ = 1, SliceKind kind_ = Contiguous, Labels_...)
if (0 < N_ && N_ < 255 && !(kind_ == Canonical && N_ == 1) && Labels_.length <= N_)
{
@optmath:
///
enum SliceKind kind = kind_;
///
enum size_t N = N_;
///
enum size_t S = kind == Universal ? N : kind == Canonical ? N - 1 : 0;
///
enum size_t L = Labels_.length;
///
alias Iterator = Iterator_;
///
alias This = Slice!(Iterator, N, kind);
///
alias DeepElement = typeof(Iterator.init[size_t.init]);
///
alias Labels = Labels_;
///
template Element(size_t dimension)
if (dimension < N)
{
static if (N == 1)
alias Element = DeepElement;
else
{
static if (kind == Universal || dimension == N - 1)
alias Element = mir_slice!(Iterator, N - 1, Universal);
else
static if (N == 2 || kind == Contiguous && dimension == 0)
alias Element = mir_slice!(Iterator, N - 1);
else
alias Element = mir_slice!(Iterator, N - 1, Canonical);
}
}
package(mir):
enum doUnittest = is(Iterator == int*) && N == 1 && kind == Contiguous;
enum hasAccessByRef = __traits(compiles, &_iterator[0]);
enum PureIndexLength(Slices...) = Filter!(isIndex, Slices).length;
enum isPureSlice(Slices...) =
Slices.length == 0
|| Slices.length <= N
&& PureIndexLength!Slices < N
&& Filter!(isIndex, Slices).length < Slices.length
&& allSatisfy!(templateOr!(isIndex, is_Slice), Slices);
enum isIndexSlice(Indexes...) =
Indexes.length
&& Indexes.length <= N
&& allSatisfy!(isIndex, Indexes);
enum isFullPureSlice(Slices...) =
Slices.length == 0
|| Slices.length == N
&& PureIndexLength!Slices < N
&& allSatisfy!(templateOr!(isIndex, is_Slice), Slices);
enum isIndexedSlice(Slices...) =
Slices.length
&& Slices.length <= N
&& allSatisfy!(templateOr!isSlice, Slices);
static if (S)
{
///
public alias _Structure = AliasSeq!(size_t[N], ptrdiff_t[S]);
///
_Structure _structure;
///
public alias _lengths = _structure[0];
///
public alias _strides = _structure[1];
}
else
{
///
public alias _Structure = AliasSeq!(size_t[N]);
///
_Structure _structure;
///
public alias _lengths = _structure[0];
///
public enum ptrdiff_t[S] _strides = ptrdiff_t[S].init;
}
///
public Iterator _iterator;
///
public Labels _labels;
sizediff_t backIndex(size_t dimension = 0)() @safe @property scope const
if (dimension < N)
{
return _stride!dimension * (_lengths[dimension] - 1);
}
size_t indexStride(size_t I)(size_t[I] _indexes) @safe scope const
{
static if (_indexes.length)
{
static if (kind == Contiguous)
{
enum E = I - 1;
assert(_indexes[E] < _lengths[E], indexError!(E, N));
ptrdiff_t ball = this._stride!E;
ptrdiff_t stride = _indexes[E] * ball;
foreach_reverse (i; Iota!E) //static
{
ball *= _lengths[i + 1];
assert(_indexes[i] < _lengths[i], indexError!(i, N));
stride += ball * _indexes[i];
}
}
else
static if (kind == Canonical)
{
enum E = I - 1;
assert(_indexes[E] < _lengths[E], indexError!(E, N));
static if (I == N)
size_t stride = _indexes[E];
else
size_t stride = _strides[E] * _indexes[E];
foreach_reverse (i; Iota!E) //static
{
assert(_indexes[i] < _lengths[i], indexError!(i, N));
stride += _strides[i] * _indexes[i];
}
}
else
{
enum E = I - 1;
assert(_indexes[E] < _lengths[E], indexError!(E, N));
size_t stride = _strides[E] * _indexes[E];
foreach_reverse (i; Iota!E) //static
{
assert(_indexes[i] < _lengths[i], indexError!(i, N));
stride += _strides[i] * _indexes[i];
}
}
return stride;
}
else
{
return 0;
}
}
public:
// static if (S == 0)
// {
/// Defined for Contiguous Slice only
// this()(size_t[N] lengths, in ptrdiff_t[] empty, Iterator iterator, Labels labels)
// {
// version(LDC) pragma(inline, true);
// assert(empty.length == 0);
// this._lengths = lengths;
// this._iterator = iterator;
// }
// /// ditto
// this()(size_t[N] lengths, Iterator iterator, Labels labels)
// {
// version(LDC) pragma(inline, true);
// this._lengths = lengths;
// this._iterator = iterator;
// }
// /// ditto
// this()(size_t[N] lengths, in ptrdiff_t[] empty, Iterator iterator, Labels labels)
// {
// version(LDC) pragma(inline, true);
// assert(empty.length == 0);
// this._lengths = lengths;
// this._iterator = iterator;
// }
// /// ditto
// this()(size_t[N] lengths, Iterator iterator, Labels labels)
// {
// version(LDC) pragma(inline, true);
// this._lengths = lengths;
// this._iterator = iterator;
// }
// }
// version(LDC)
// private enum classicConstructor = true;
// else
// private enum classicConstructor = S > 0;
// static if (classicConstructor)
// {
/// Defined for Canonical and Universal Slices (DMD, GDC, LDC) and for Contiguous Slices (LDC)
// this()(size_t[N] lengths, ptrdiff_t[S] strides, Iterator iterator, Labels labels)
// {
// version(LDC) pragma(inline, true);
// this._lengths = lengths;
// this._strides = strides;
// this._iterator = iterator;
// this._labels = labels;
// }
// /// ditto
// this()(size_t[N] lengths, ptrdiff_t[S] strides, ref Iterator iterator, Labels labels)
// {
// version(LDC) pragma(inline, true);
// this._lengths = lengths;
// this._strides = strides;
// this._iterator = iterator;
// this._labels = labels;
// }
// }
// /// Construct from null
// this()(typeof(null))
// {
// version(LDC) pragma(inline, true);
// }
// static if (doUnittest)
// ///
// @safe pure version(mir_test) unittest
// {
// import mir.ndslice.slice;
// alias Array = Slice!(double*);
// Array a = null;
// auto b = Array(null);
// assert(a.empty);
// assert(b.empty);
// auto fun(Array a = null)
// {
// }
// }
static if (doUnittest)
/// Creates a 2-dimentional slice with custom strides.
nothrow pure
version(mir_test) unittest
{
uint[8] array = [1, 2, 3, 4, 5, 6, 7, 8];
auto slice = Slice!(uint*, 2, Universal)([2, 2], [4, 1], array.ptr);
assert(&slice[0, 0] == &array[0]);
assert(&slice[0, 1] == &array[1]);
assert(&slice[1, 0] == &array[4]);
assert(&slice[1, 1] == &array[5]);
assert(slice == [[1, 2], [5, 6]]);
array[2] = 42;
assert(slice == [[1, 2], [5, 6]]);
array[1] = 99;
assert(slice == [[1, 99], [5, 6]]);
}
///
auto lightImmutable()() scope return immutable @property
{
return Slice!(LightImmutableOf!Iterator, N, kind)(_structure, _iterator.lightImmutable);
}
/// ditto
auto lightConst()() scope return const @property
{
return Slice!(LightConstOf!Iterator, N, kind)(_structure, _iterator.lightConst);
}
/// ditto
auto lightConst()() scope return immutable @property
{
return this.lightImmutable;
}
/// ditto
auto ref opIndex(Indexes...)(Indexes indexes) scope return const @trusted
if (isPureSlice!Indexes || isIndexedSlice!Indexes || isIndexSlice!Indexes)
{
return this.lightConst[indexes];
}
/// ditto
auto ref opIndex(Indexes...)(Indexes indexes) scope return immutable @trusted
if (isPureSlice!Indexes || isIndexedSlice!Indexes || isIndexSlice!Indexes)
{
return this.lightImmutable[indexes];
}
static if (isPointer!Iterator)
{
private alias ConstThis = Slice!(const(Unqual!(PointerTarget!Iterator))*, N, kind);
private alias ImmutableThis = Slice!(immutable(Unqual!(PointerTarget!Iterator))*, N, kind);
/++
Cast to const and immutable slices in case of underlying range is a pointer.
+/
auto toImmutable()() scope return immutable @trusted pure nothrow @nogc
{
alias It = immutable(Unqual!(PointerTarget!Iterator))*;
return Slice!(It, N, kind)(_structure, _iterator);
}
/// ditto
auto toConst()() scope return const @trusted pure nothrow @nogc
{
version(LDC) pragma(inline, true);
alias It = const(Unqual!(PointerTarget!Iterator))*;
return Slice!(It, N, kind)(_structure, _iterator);
}
static if (!is(Slice!(const(Unqual!(PointerTarget!Iterator))*, N, kind) == This))
/// ditto
alias toConst this;
static if (doUnittest)
///
version(mir_test) unittest
{
static struct Foo
{
Slice!(int*) bar;
int get(size_t i) immutable
{
return bar[i];
}
int get(size_t i) const
{
return bar[i];
}
int get(size_t i) inout
{
return bar[i];
}
}
}
static if (doUnittest)
///
version(mir_test) unittest
{
Slice!(double*, 2, Universal) nn;
Slice!(immutable(double)*, 2, Universal) ni;
Slice!(const(double)*, 2, Universal) nc;
const Slice!(double*, 2, Universal) cn;
const Slice!(immutable(double)*, 2, Universal) ci;
const Slice!(const(double)*, 2, Universal) cc;
immutable Slice!(double*, 2, Universal) in_;
immutable Slice!(immutable(double)*, 2, Universal) ii;
immutable Slice!(const(double)*, 2, Universal) ic;
nc = nc; nc = cn; nc = in_;
nc = nc; nc = cc; nc = ic;
nc = ni; nc = ci; nc = ii;
void fun(T, size_t N)(Slice!(const(T)*, N, Universal) sl)
{
//...
}
fun(nn); fun(cn); fun(in_);
fun(nc); fun(cc); fun(ic);
fun(ni); fun(ci); fun(ii);
static assert(is(typeof(cn[]) == typeof(nc)));
static assert(is(typeof(ci[]) == typeof(ni)));
static assert(is(typeof(cc[]) == typeof(nc)));
static assert(is(typeof(in_[]) == typeof(ni)));
static assert(is(typeof(ii[]) == typeof(ni)));
static assert(is(typeof(ic[]) == typeof(ni)));
ni = ci[];
ni = in_[];
ni = ii[];
ni = ic[];
}
}
/++
Iterator
Returns:
Iterator (pointer) to the $(LREF Slice.first) element.
+/
auto iterator()() inout scope return @property
{
return _iterator;
}
/++
+/
auto label(size_t dimension)() scope return @trusted inout @property
if (dimension <= L)
{
return label.sliced(_lengths[dimension]);
}
static if (kind == Contiguous && isPointer!Iterator)
/++
`ptr` alias is available only if the slice kind is $(LREF Contiguous) contiguous and the $(LREF Slice.iterator) is a pointers.
+/
alias ptr = iterator;
else
{
import mir.rcarray: mir_rci;
static if (kind == Contiguous && is(Iterator : mir_rci!ET, ET))
auto ptr() scope return inout @property
{
return _iterator._iterator;
}
}
/++
Field (array) data.
Returns:
Raw data slice.
Constraints:
Field is defined only for contiguous slices.
+/
auto field()() scope return @trusted @property
{
static assert(kind == Contiguous, "Slice.field is defined only for contiguous slices. Slice kind is " ~ kind.stringof);
static if (is(typeof(_iterator[size_t(0) .. elementCount])))
{
return _iterator[size_t(0) .. elementCount];
}
else
{
import mir.ndslice.topology: flattened;
return this.flattened;
}
}
static if (doUnittest)
///
@safe version(mir_test) unittest
{
auto arr = [1, 2, 3, 4];
auto sl0 = arr.sliced;
auto sl1 = arr.slicedField;
assert(sl0.field is arr);
assert(sl1.field is arr);
arr = arr[1 .. $];
sl0 = sl0[1 .. $];
sl1 = sl1[1 .. $];
assert(sl0.field is arr);
assert(sl1.field is arr);
}
/++
Returns: static array of lengths
See_also: $(LREF .Slice.structure)
+/
size_t[N] shape()() @trusted @property scope const
{
return _lengths[0 .. N];
}
static if (doUnittest)
/// Regular slice
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
assert(iota(3, 4, 5).shape == cast(size_t[3])[3, 4, 5]);
}
static if (doUnittest)
/// Packed slice
@safe @nogc pure nothrow
version(mir_test) unittest
{
import mir.ndslice.topology : pack, iota;
size_t[3] s = [3, 4, 5];
assert(iota(3, 4, 5, 6, 7).pack!2.shape == s);
}
/++
Returns: static array of lengths
See_also: $(LREF .Slice.structure)
+/
ptrdiff_t[N] strides()() @trusted @property scope const
{
static if (N <= S)
return _strides[0 .. N];
else
{
typeof(return) ret;
static if (kind == Canonical)
{
foreach (i; Iota!S)
ret[i] = _strides[i];
ret[$-1] = 1;
}
else
{
ret[$ - 1] = _stride!(N - 1);
foreach_reverse (i; Iota!(N - 1))
ret[i] = ret[i + 1] * _lengths[i + 1];
}
return ret;
}
}
static if (doUnittest)
/// Regular slice
@safe @nogc pure nothrow
version(mir_test) unittest
{
import mir.ndslice.topology : iota;
size_t[3] s = [20, 5, 1];
assert(iota(3, 4, 5).strides == s);
}
static if (doUnittest)
/// Modified regular slice
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : pack, iota, universal;
import mir.ndslice.dynamic : reversed, strided, transposed;
assert(iota(3, 4, 50)
.universal
.reversed!2 //makes stride negative
.strided!2(6) //multiplies stride by 6 and changes corresponding length
.transposed!2 //brings dimension `2` to the first position
.strides == cast(ptrdiff_t[3])[-6, 200, 50]);
}
static if (doUnittest)
/// Packed slice
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : pack, iota;
size_t[3] s = [20 * 42, 5 * 42, 1 * 42];
assert(iota(3, 4, 5, 6, 7)
.pack!2
.strides == s);
}
/++
Returns: static array of lengths and static array of strides
See_also: $(LREF .Slice.shape)
+/
Structure!N structure()() @safe @property scope const
{
return typeof(return)(_lengths, strides);
}
static if (doUnittest)
/// Regular slice
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
assert(iota(3, 4, 5)
.structure == Structure!3([3, 4, 5], [20, 5, 1]));
}
static if (doUnittest)
/// Modified regular slice
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : pack, iota, universal;
import mir.ndslice.dynamic : reversed, strided, transposed;
assert(iota(3, 4, 50)
.universal
.reversed!2 //makes stride negative
.strided!2(6) //multiplies stride by 6 and changes corresponding length
.transposed!2 //brings dimension `2` to the first position
.structure == Structure!3([9, 3, 4], [-6, 200, 50]));
}
static if (doUnittest)
/// Packed slice
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : pack, iota;
assert(iota(3, 4, 5, 6, 7)
.pack!2
.structure == Structure!3([3, 4, 5], [20 * 42, 5 * 42, 1 * 42]));
}
/++
Save primitive.
+/
auto save()() scope return inout @property
{
return this;
}
static if (doUnittest)
/// Save range
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
auto slice = iota(2, 3).save;
}
static if (doUnittest)
/// Pointer type.
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
//sl type is `Slice!(2, int*)`
auto sl = slice!int(2, 3).save;
}
/++
Multidimensional `length` property.
Returns: length of the corresponding dimension
See_also: $(LREF .Slice.shape), $(LREF .Slice.structure)
+/
size_t length(size_t dimension = 0)() @safe @property scope const
if (dimension < N)
{
return _lengths[dimension];
}
static if (doUnittest)
///
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
auto slice = iota(3, 4, 5);
assert(slice.length == 3);
assert(slice.length!0 == 3);
assert(slice.length!1 == 4);
assert(slice.length!2 == 5);
}
alias opDollar = length;
/++
Multidimensional `stride` property.
Returns: stride of the corresponding dimension
See_also: $(LREF .Slice.structure)
+/
sizediff_t _stride(size_t dimension = 0)() @safe @property scope const
if (dimension < N)
{
static if (dimension < S)
{
return _strides[dimension];
}
else
static if (dimension + 1 == N)
{
return 1;
}
else
{
size_t ball = _lengths[$ - 1];
foreach_reverse(i; Iota!(dimension + 1, N - 1))
ball *= _lengths[i];
return ball;
}
}
static if (doUnittest)
/// Regular slice
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
auto slice = iota(3, 4, 5);
assert(slice._stride == 20);
assert(slice._stride!0 == 20);
assert(slice._stride!1 == 5);
assert(slice._stride!2 == 1);
}
static if (doUnittest)
/// Modified regular slice
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.dynamic : reversed, strided, swapped;
import mir.ndslice.topology : universal, iota;
assert(iota(3, 4, 50)
.universal
.reversed!2 //makes stride negative
.strided!2(6) //multiplies stride by 6 and changes the corresponding length
.swapped!(1, 2) //swaps dimensions `1` and `2`
._stride!1 == -6);
}
/++
Multidimensional input range primitive.
+/
bool empty(size_t dimension = 0)() @safe @property scope const
if (dimension < N)
{
return _lengths[dimension] == 0;
}
///ditto
static if (N == 1)
auto ref front(size_t dimension = 0)() scope return @trusted @property
if (dimension == 0)
{
assert(!empty!dimension);
return *_iterator;
}
else
Element!dimension front(size_t dimension = 0)() scope return @property
if (dimension < N)
{
typeof(return)._Structure structure_ = typeof(return)._Structure.init;
foreach (i; Iota!(typeof(return).N))
{
enum j = i >= dimension ? i + 1 : i;
structure_[0][i] = _lengths[j];
}
static if (!typeof(return).S || typeof(return).S + 1 == S)
alias s = _strides;
else
auto s = strides;
foreach (i; Iota!(typeof(return).S))
{
enum j = i >= dimension ? i + 1 : i;
structure_[1][i] = s[j];
}
return typeof(return)(structure_, _iterator);
}
static if (N == 1 && isMutable!DeepElement && !hasAccessByRef)
{
///ditto
auto ref front(size_t dimension = 0, T)(T value) scope return @trusted @property
if (dimension == 0)
{
// check assign safety
static auto ref fun(ref DeepElement t, ref T v) @safe
{
return t = v;
}
assert(!empty!dimension);
static if (__traits(compiles, *_iterator = value))
return *_iterator = value;
else
return _iterator[0] = value;
}
}
///ditto
static if (N == 1)
auto ref Element!dimension
back(size_t dimension = 0)() scope return @trusted @property
if (dimension < N)
{
assert(!empty!dimension);
return _iterator[backIndex];
}
else
auto ref Element!dimension
back(size_t dimension = 0)() scope return @trusted @property
if (dimension < N)
{
assert(!empty!dimension);
auto structure_ = typeof(return)._Structure.init;
foreach (i; Iota!(typeof(return).N))
{
enum j = i >= dimension ? i + 1 : i;
structure_[0][i] = _lengths[j];
}
static if (!typeof(return).S || typeof(return).S + 1 == S)
alias s =_strides;
else
auto s = strides;
foreach (i; Iota!(typeof(return).S))
{
enum j = i >= dimension ? i + 1 : i;
structure_[1][i] = s[j];
}
return typeof(return)(structure_, _iterator + backIndex!dimension);
}
static if (N == 1 && isMutable!DeepElement && !hasAccessByRef)
{
///ditto
auto ref back(size_t dimension = 0, T)(T value) scope return @trusted @property
if (dimension == 0)
{
// check assign safety
static auto ref fun(ref DeepElement t, ref T v) @safe
{
return t = v;
}
assert(!empty!dimension);
return _iterator[backIndex] = value;
}
}
///ditto
void popFront(size_t dimension = 0)() @trusted scope
if (dimension < N && (dimension == 0 || kind != Contiguous))
{
assert(_lengths[dimension], __FUNCTION__ ~ ": length!" ~ dimension.stringof ~ " should be greater than 0.");
_lengths[dimension]--;
static if ((kind == Contiguous || kind == Canonical) && dimension + 1 == N)
++_iterator;
else
static if (kind == Canonical || kind == Universal)
_iterator += _strides[dimension];
else
_iterator += _stride!dimension;
}
///ditto
void popBack(size_t dimension = 0)() @safe scope
if (dimension < N && (dimension == 0 || kind != Contiguous))
{
assert(_lengths[dimension], __FUNCTION__ ~ ": length!" ~ dimension.stringof ~ " should be greater than 0.");
--_lengths[dimension];
}
///ditto
void popFrontExactly(size_t dimension = 0)(size_t n) @trusted scope
if (dimension < N && (dimension == 0 || kind != Contiguous))
{
assert(n <= _lengths[dimension],
__FUNCTION__ ~ ": n should be less than or equal to length!" ~ dimension.stringof);
_lengths[dimension] -= n;
_iterator += _stride!dimension * n;
}
///ditto
void popBackExactly(size_t dimension = 0)(size_t n) @safe scope
if (dimension < N && (dimension == 0 || kind != Contiguous))
{
assert(n <= _lengths[dimension],
__FUNCTION__ ~ ": n should be less than or equal to length!" ~ dimension.stringof);
_lengths[dimension] -= n;
}
///ditto
void popFrontN(size_t dimension = 0)(size_t n) @trusted scope
if (dimension < N && (dimension == 0 || kind != Contiguous))
{
popFrontExactly!dimension(min(n, _lengths[dimension]));
}
///ditto
void popBackN(size_t dimension = 0)(size_t n) @safe scope
if (dimension < N && (dimension == 0 || kind != Contiguous))
{
popBackExactly!dimension(min(n, _lengths[dimension]));
}
static if (doUnittest)
///
@safe @nogc pure nothrow version(mir_test) unittest
{
import std.range.primitives;
import mir.ndslice.topology : iota, canonical;
auto slice = iota(10, 20, 30).canonical;
static assert(isRandomAccessRange!(typeof(slice)));
static assert(hasSlicing!(typeof(slice)));
static assert(hasLength!(typeof(slice)));
assert(slice.shape == cast(size_t[3])[10, 20, 30]);
slice.popFront;
slice.popFront!1;
slice.popBackExactly!2(4);
assert(slice.shape == cast(size_t[3])[9, 19, 26]);
auto matrix = slice.front!1;
assert(matrix.shape == cast(size_t[2])[9, 26]);
auto column = matrix.back!1;
assert(column.shape == cast(size_t[1])[9]);
slice.popFrontExactly!1(slice.length!1);
assert(slice.empty == false);
assert(slice.empty!1 == true);
assert(slice.empty!2 == false);
assert(slice.shape == cast(size_t[3])[9, 0, 26]);
assert(slice.back.front!1.empty);
slice.popFrontN!0(40);
slice.popFrontN!2(40);
assert(slice.shape == cast(size_t[3])[0, 0, 0]);
}
package(mir) ptrdiff_t lastIndex()() @safe @property scope const
{
static if (kind == Contiguous)
{
return elementCount - 1;
}
else
{
auto strides = strides;
ptrdiff_t shift = 0;
foreach(i; Iota!N)
shift += strides[i] * (_lengths[i] - 1);
return shift;
}
}
static if (N > 1)
{
/// Accesses the first deep element of the slice.
auto ref first()() scope return @trusted @property
{
assert(!anyEmpty);
return *_iterator;
}
static if (isMutable!DeepElement && !hasAccessByRef)
///ditto
auto ref first(T)(T value) scope return @trusted @property
{
assert(!anyEmpty);
static if (__traits(compiles, *_iterator = value))
return *_iterator = value;
else
return _iterator[0] = value;
}
static if (doUnittest)
///
@safe pure nothrow @nogc version(mir_test) unittest
{
import mir.ndslice.topology: iota, universal, canonical;
auto f = 5;
assert([2, 3].iota(f).first == f);
}
/// Accesses the last deep element of the slice.
auto ref last()() @trusted scope return @property
{
assert(!anyEmpty);
return _iterator[lastIndex];
}
static if (isMutable!DeepElement && !hasAccessByRef)
///ditto
auto ref last(T)(T value) @trusted scope return @property
{
assert(!anyEmpty);
return _iterator[lastIndex] = value;
}
static if (doUnittest)
///
@safe pure nothrow @nogc version(mir_test) unittest
{
import mir.ndslice.topology: iota;
auto f = 5;
assert([2, 3].iota(f).last == f + 2 * 3 - 1);
}
}
else
{
alias first = front;
alias last = back;
}
/+
Returns: `true` if for any dimension of completely unpacked slice the length equals to `0`, and `false` otherwise.
+/
private bool anyRUEmpty()() @trusted @property scope const
{
static if (isInstanceOf!(SliceIterator, Iterator))
{
import mir.ndslice.topology: unpack;
return this[].unpack.anyRUEmpty;
}
else
return _lengths[0 .. N].anyEmptyShape;
}
/++
Returns: `true` if for any dimension the length equals to `0`, and `false` otherwise.
+/
bool anyEmpty()() @trusted @property scope const
{
return _lengths[0 .. N].anyEmptyShape;
}
static if (doUnittest)
///
@safe pure nothrow @nogc version(mir_test) unittest
{
import mir.ndslice.topology : iota, canonical;
auto s = iota(2, 3).canonical;
assert(!s.anyEmpty);
s.popFrontExactly!1(3);
assert(s.anyEmpty);
}
/++
Convenience function for backward indexing.
Returns: `this[$-index[0], $-index[1], ..., $-index[N-1]]`
+/
auto ref backward()(size_t[N] index) scope return
{
foreach (i; Iota!N)
index[i] = _lengths[i] - index[i];
return this[index];
}
/// ditto
auto ref backward()(size_t[N] index) scope return const
{
return this.lightConst.backward(index);
}
/// ditto
auto ref backward()(size_t[N] index) scope return const
{
return this.lightConst.backward(index);
}
static if (doUnittest)
///
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
auto s = iota(2, 3);
assert(s[$ - 1, $ - 2] == s.backward([1, 2]));
}
/++
Returns: Total number of elements in a slice
+/
size_t elementCount()() @safe @property scope const
{
size_t len = 1;
foreach (i; Iota!N)
len *= _lengths[i];
return len;
}
deprecated("use elementCount instead")
alias elementsCount = elementCount;
static if (doUnittest)
/// Regular slice
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
assert(iota(3, 4, 5).elementCount == 60);
}
static if (doUnittest)
/// Packed slice
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : pack, evertPack, iota;
auto slice = iota(3, 4, 5, 6, 7, 8);
auto p = slice.pack!2;
assert(p.elementCount == 360);
assert(p[0, 0, 0, 0].elementCount == 56);
assert(p.evertPack.elementCount == 56);
}
/++
Slice selected dimension.
Params:
begin = initial index of the sub-slice (inclusive)
end = final index of the sub-slice (noninclusive)
Returns: ndslice with `length!dimension` equal to `end - begin`.
+/
auto select(size_t dimension)(size_t begin, size_t end) scope return
{
static if (kind == Contiguous && dimension)
{
import mir.ndslice.topology: canonical;
auto ret = this.canonical;
}
else
{
auto ret = this;
}
auto len = end - begin;
assert(len <= ret._lengths[dimension]);
ret._lengths[dimension] = len;
ret._iterator += ret._stride!dimension * begin;
return ret;
}
static if (doUnittest)
///
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
auto sl = iota(3, 4);
assert(sl.select!1(1, 3) == sl[0 .. $, 1 .. 3]);
}
/++
Select the first n elements for the dimension.
Params:
dimension = Dimension to slice.
n = count of elements for the dimension
Returns: ndslice with `length!dimension` equal to `n`.
+/
auto selectFront(size_t dimension)(size_t n) scope return
{
static if (kind == Contiguous && dimension)
{
import mir.ndslice.topology: canonical;
auto ret = this.canonical;
}
else
{
auto ret = this;
}
assert(n <= ret._lengths[dimension]);
ret._lengths[dimension] = n;
return ret;
}
static if (doUnittest)
///
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
auto sl = iota(3, 4);
assert(sl.selectFront!1(2) == sl[0 .. $, 0 .. 2]);
}
/++
Select the last n elements for the dimension.
Params:
dimension = Dimension to slice.
n = count of elements for the dimension
Returns: ndslice with `length!dimension` equal to `n`.
+/
auto selectBack(size_t dimension)(size_t n) scope return
{
static if (kind == Contiguous && dimension)
{
import mir.ndslice.topology: canonical;
auto ret = this.canonical;
}
else
{
auto ret = this;
}
assert(n <= ret._lengths[dimension]);
ret._iterator += ret._stride!dimension * (ret._lengths[dimension] - n);
ret._lengths[dimension] = n;
return ret;
}
static if (doUnittest)
///
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
auto sl = iota(3, 4);
assert(sl.selectBack!1(2) == sl[0 .. $, $ - 2 .. $]);
}
/++
Overloading `==` and `!=`
+/
bool opEquals(IteratorR, SliceKind rkind)(const Slice!(IteratorR, N, rkind) rslice) @trusted scope const
{
static if (
!hasReference!(typeof(this))
&& !hasReference!(typeof(rslice))
&& __traits(compiles, this._iterator == rslice._iterator)
)
{
if (this._lengths != rslice._lengths)
return false;
static if (kind == rkind)
{
if (this._strides != rslice._strides)
return false;
}
else
{
if (this.strides != rslice.strides)
return false;
}
if (this._iterator == rslice._iterator)
return true;
}
import mir.algorithm.iteration : equal;
return equal(this.lightConst, rslice.lightConst);
}
/// ditto
bool opEquals(T)(scope const(T)[] arr) @trusted scope const
{
auto slice = this.lightConst;
if (slice.length != arr.length)
return false;
if (arr.length) do
{
if (slice.front != arr[0])
return false;
slice.popFront;
arr = arr[1 .. $];
}
while (arr.length);
return true;
}
static if (doUnittest)
///
@safe pure nothrow
version(mir_test) unittest
{
auto a = [1, 2, 3, 4].sliced(2, 2);
assert(a != [1, 2, 3, 4, 5, 6].sliced(2, 3));
assert(a != [[1, 2, 3], [4, 5, 6]]);
assert(a == [1, 2, 3, 4].sliced(2, 2));
assert(a == [[1, 2], [3, 4]]);
assert(a != [9, 2, 3, 4].sliced(2, 2));
assert(a != [[9, 2], [3, 4]]);
}
static if (doUnittest)
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation: slice;
import mir.ndslice.topology : iota;
assert(iota(2, 3).slice[0 .. $ - 2] == iota([4, 3], 2)[0 .. $ - 4]);
}
_Slice!() opSlice(size_t dimension)(size_t i, size_t j) @safe scope const
if (dimension < N)
in
{
assert(i <= j,
"Slice.opSlice!" ~ dimension.stringof ~ ": the left bound must be less than or equal to the right bound.");
enum errorMsg = ": the right must be less than or equal to the length of the given dimension.";
assert(j <= _lengths[dimension],
"Slice.opSlice!" ~ dimension.stringof ~ errorMsg);
}
body
{
return typeof(return)(i, j);
}
/++
$(BOLD Fully defined index)
+/
auto ref opIndex()(size_t[N] _indexes...) scope return @trusted
{
return _iterator[indexStride(_indexes)];
}
/// ditto
auto ref opIndex()(size_t[N] _indexes...) scope return const @trusted
{
static if (is(typeof(_iterator[indexStride(_indexes)])))
return _iterator[indexStride(_indexes)];
else
return lightConst[_indexes];
}
/// ditto
auto ref opIndex()(size_t[N] _indexes...) scope return immutable @trusted
{
static if (is(typeof(_iterator[indexStride(_indexes)])))
return _iterator[indexStride(_indexes)];
else
return lightImmutable[_indexes];
}
/++
$(BOLD Partially defined index)
+/
auto opIndex(size_t I)(size_t[I] _indexes...) scope return @trusted
if (I && I < N)
{
enum size_t diff = N - I;
alias Ret = Slice!(Iterator, diff, diff == 1 && kind == Canonical ? Contiguous : kind);
static if (I < S)
return Ret(_lengths[I .. N], _strides[I .. S], _iterator + indexStride(_indexes));
else
return Ret(_lengths[I .. N], _iterator + indexStride(_indexes));
}
/// ditto
auto opIndex(size_t I)(size_t[I] _indexes...) scope return const
if (I && I < N)
{
return this.lightConst[_indexes];
}
/// ditto
auto opIndex(size_t I)(size_t[I] _indexes...) scope return immutable
if (I && I < N)
{
return this.lightImmutable[_indexes];
}
/++
$(BOLD Partially or fully defined slice.)
+/
auto opIndex(Slices...)(Slices slices) scope return @trusted
if (isPureSlice!Slices)
{
static if (Slices.length)
{
enum size_t j(size_t n) = n - Filter!(isIndex, Slices[0 .. n]).length;
enum size_t F = PureIndexLength!Slices;
enum size_t S = Slices.length;
static assert(N - F > 0);
size_t stride;
static if (Slices.length == 1)
enum K = kind;
else
static if (kind == Universal || Slices.length == N && isIndex!(Slices[$-1]))
enum K = Universal;
else
static if (Filter!(isIndex, Slices[0 .. $-1]).length == Slices.length - 1 || N - F == 1)
enum K = Contiguous;
else
enum K = Canonical;
alias Ret = Slice!(Iterator, N - F, K);
auto structure_ = Ret._Structure.init;
enum bool shrink = kind == Canonical && slices.length == N;
static if (shrink)
{
{
enum i = Slices.length - 1;
auto slice = slices[i];
static if (isIndex!(Slices[i]))
{
assert(slice < _lengths[i], "Slice.opIndex: index must be less than length");
stride += slice;
}
else
{
stride += slice.i;
structure_[0][j!i] = slice.j - slice.i;
}
}
}
static if (kind == Universal || kind == Canonical)
{
foreach_reverse (i, slice; slices[0 .. $ - shrink]) //static
{
static if (isIndex!(Slices[i]))
{
assert(slice < _lengths[i], "Slice.opIndex: index must be less than length");
stride += _strides[i] * slice;
}
else
{
stride += _strides[i] * slice.i;
structure_[0][j!i] = slice.j - slice.i;
structure_[1][j!i] = _strides[i];
}
}
}
else
{
ptrdiff_t ball = this._stride!(slices.length - 1);
foreach_reverse (i, slice; slices) //static
{
static if (isIndex!(Slices[i]))
{
assert(slice < _lengths[i], "Slice.opIndex: index must be less than length");
stride += ball * slice;
}
else
{
stride += ball * slice.i;
structure_[0][j!i] = slice.j - slice.i;
static if (j!i < Ret.S)
structure_[1][j!i] = ball;
}
static if (i)
ball *= _lengths[i];
}
}
foreach (i; Iota!(Slices.length, N))
structure_[0][i - F] = _lengths[i];
foreach (i; Iota!(Slices.length, N))
static if (Ret.S > i - F)
structure_[1][i - F] = _strides[i];
return Ret(structure_, _iterator + stride);
}
else
{
return this;
}
}
static if (doUnittest)
///
pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
auto slice = slice!int(5, 3);
/// Fully defined slice
assert(slice[] == slice);
auto sublice = slice[0..$-2, 1..$];
/// Partially defined slice
auto row = slice[3];
auto col = slice[0..$, 1];
}
/++
$(BOLD Indexed slice.)
+/
auto opIndex(Slices...)(scope return Slices slices) scope return
if (isIndexedSlice!Slices)
{
import mir.ndslice.topology: indexed, cartesian;
static if (Slices.length == 1)
alias index = slices[0];
else
auto index = slices.cartesian;
return this.indexed(index);
}
static if (doUnittest)
///
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation: slice;
auto sli = slice!int(4, 3);
auto idx = slice!(size_t[2])(3);
idx[] = [
cast(size_t[2])[0, 2],
cast(size_t[2])[3, 1],
cast(size_t[2])[2, 0]];
// equivalent to:
// import mir.ndslice.topology: indexed;
// sli.indexed(indx)[] = 1;
sli[idx][] = 1;
assert(sli == [
[0, 0, 1],
[0, 0, 0],
[1, 0, 0],
[0, 1, 0],
]);
foreach (row; sli[[1, 3].sliced])
row[] += 2;
assert(sli == [
[0, 0, 1],
[2, 2, 2], // <-- += 2
[1, 0, 0],
[2, 3, 2], // <-- += 2
]);
}
static if (doUnittest)
///
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology: iota;
import mir.ndslice.allocation: slice;
auto sli = slice!int(5, 6);
// equivalent to
// import mir.ndslice.topology: indexed, cartesian;
// auto a = [0, sli.length!0 / 2, sli.length!0 - 1].sliced;
// auto b = [0, sli.length!1 / 2, sli.length!1 - 1].sliced;
// auto c = cartesian(a, b);
// auto minor = sli.indexed(c);
auto minor = sli[[0, $ / 2, $ - 1].sliced, [0, $ / 2, $ - 1].sliced];
minor[] = iota!int([3, 3], 1);
assert(sli == [
// ↓ ↓ ↓︎
[1, 0, 0, 2, 0, 3], // <---
[0, 0, 0, 0, 0, 0],
[4, 0, 0, 5, 0, 6], // <---
[0, 0, 0, 0, 0, 0],
[7, 0, 0, 8, 0, 9], // <---
]);
}
/++
Element-wise binary operator overloading.
Returns:
lazy slice of the same kind and the same structure
Note:
Does not allocate neither new slice nor a closure.
+/
auto opUnary(string op)() scope return
if (op == "*" || op == "~" || op == "-" || op == "+")
{
import mir.ndslice.topology: map;
static if (op == "+")
return this;
else
return this.map!(op ~ "a");
}
static if (doUnittest)
///
version(mir_test) unittest
{
import mir.ndslice.topology;
auto payload = [1, 2, 3, 4];
auto s = iota([payload.length], payload.ptr); // slice of references;
assert(s[1] == payload.ptr + 1);
auto c = *s; // the same as s.map!"*a"
assert(c[1] == *s[1]);
*s[1] = 3;
assert(c[1] == *s[1]);
}
/++
Element-wise operator overloading for scalars.
Params:
value = a scalar
Returns:
lazy slice of the same kind and the same structure
Note:
Does not allocate neither new slice nor a closure.
+/
auto opBinary(string op, T)(scope return T value) scope return
if(!isSlice!T)
{
import mir.ndslice.topology: vmap;
return this.vmap(LeftOp!(op, ImplicitlyUnqual!T)(value));
}
/// ditto
auto opBinaryRight(string op, T)(scope return T value) scope return
if(!isSlice!T)
{
import mir.ndslice.topology: vmap;
return this.vmap(RightOp!(op, ImplicitlyUnqual!T)(value));
}
static if (doUnittest)
///
@safe pure nothrow @nogc version(mir_test) unittest
{
import mir.ndslice.topology;
// 0 1 2 3
auto s = iota([4]);
// 0 1 2 0
assert(s % 3 == iota([4]).map!"a % 3");
// 0 2 4 6
assert(2 * s == iota([4], 0, 2));
}
static if (doUnittest)
///
@safe pure nothrow @nogc version(mir_test) unittest
{
import mir.ndslice.topology;
// 0 1 2 3
auto s = iota([4]);
// 0 1 4 9
assert(s ^^ 2.0 == iota([4]).map!"a ^^ 2.0");
}
/++
Element-wise operator overloading for slices.
Params:
rhs = a slice of the same shape.
Returns:
lazy slice the same shape that has $(LREF Contiguous) kind
Note:
Binary operator overloading is allowed if both slices are contiguous or one-dimensional.
$(BR)
Does not allocate neither new slice nor a closure.
+/
auto opBinary(string op, RIterator, size_t RN, SliceKind rkind)
(scope return Slice!(RIterator, RN, rkind) rhs) scope return
if(N == RN && (kind == Contiguous && rkind == Contiguous || N == 1) && op != "~")
{
import mir.ndslice.topology: zip, map;
return zip(this, rhs).map!("a " ~ op ~ " b");
}
static if (doUnittest)
///
@safe pure nothrow @nogc version(mir_test) unittest
{
import mir.ndslice.topology: iota, map, zip;
auto s = iota([2, 3]);
auto c = iota([2, 3], 5, 8);
assert(s * s + c == s.map!"a * a".zip(c).map!"a + b");
}
/++
Duplicates slice.
Returns: GC-allocated Contiguous mutable slice.
See_also: $(LREF Slice.idup)
+/
Slice!(Unqual!DeepElement*, N)
dup()() scope @property
{
if (__ctfe)
{
import mir.ndslice.topology: flattened;
import mir.array.allocation: array;
return this.flattened.array.dup.sliced(this.shape);
}
else
{
import mir.ndslice.allocation: uninitSlice;
import mir.conv: emplaceRef;
alias E = this.DeepElement;
auto result = (() @trusted => this.shape.uninitSlice!(Unqual!E))();
import mir.algorithm.iteration: each;
each!(emplaceRef!(Unqual!E))(result, this);
return result;
}
}
/// ditto
Slice!(immutable(DeepElement)*, N)
dup()() scope const @property
{
this[].dup;
}
/// ditto
Slice!(immutable(DeepElement)*, N)
dup()() scope immutable @property
{
this[].dup;
}
static if (doUnittest)
///
@safe pure version(mir_test) unittest
{
import mir.ndslice;
auto x = 3.iota!int;
Slice!(immutable(int)*) imm = x.idup;
Slice!(int*) mut = imm.dup;
assert(imm == x);
assert(mut == x);
}
/++
Duplicates slice.
Returns: GC-allocated Contiguous immutable slice.
See_also: $(LREF Slice.dup)
+/
Slice!(immutable(DeepElement)*, N)
idup()() scope @property
{
if (__ctfe)
{
import mir.ndslice.topology: flattened;
import mir.array.allocation: array;
return this.flattened.array.idup.sliced(this.shape);
}
else
{
import mir.ndslice.allocation: uninitSlice;
import mir.conv: emplaceRef;
alias E = this.DeepElement;
auto result = (() @trusted => this.shape.uninitSlice!(Unqual!E))();
import mir.algorithm.iteration: each;
each!(emplaceRef!(immutable E))(result, this);
alias R = typeof(return);
return (() @trusted => cast(R) result)();
}
}
/// ditto
Slice!(immutable(DeepElement)*, N)
idup()() scope const @property
{
this[].idup;
}
/// ditto
Slice!(immutable(DeepElement)*, N)
idup()() scope immutable @property
{
this[].idup;
}
static if (doUnittest)
///
@safe pure version(mir_test) unittest
{
import mir.ndslice;
auto x = 3.iota!int;
Slice!(int*) mut = x.dup;
Slice!(immutable(int)*) imm = mut.idup;
assert(imm == x);
assert(mut == x);
}
static if (isMutable!DeepElement)
{
private void opIndexOpAssignImplSlice(string op, RIterator, size_t RN, SliceKind rkind)
(scope Slice!(RIterator, RN, rkind) value) scope
{
static if (N > 1 && RN == N && kind == Contiguous && rkind == Contiguous)
{
import mir.ndslice.topology : flattened;
this.flattened.opIndexOpAssignImplSlice!op(value.flattened);
}
else
{
auto ls = this;
do
{
static if (N > RN)
{
ls.front.opIndexOpAssignImplSlice!op(value);
}
else
{
static if (ls.N == 1)
{
static if (isInstanceOf!(SliceIterator, Iterator))
{
static if (isSlice!(typeof(value.front)))
ls.front.opIndexOpAssignImplSlice!op(value.front);
else
static if (isDynamicArray!(typeof(value.front)))
ls.front.opIndexOpAssignImplSlice!op(value.front);
else
ls.front.opIndexOpAssignImplValue!op(value.front);
}
else
static if (op == "^^" && isFloatingPoint!(typeof(ls.front)) && isFloatingPoint!(typeof(value.front)))
{
import mir.math.common: pow;
ls.front = pow(ls.front, value.front);
}
else
mixin("ls.front " ~ op ~ "= value.front;");
}
else
static if (RN == 1)
ls.front.opIndexOpAssignImplValue!op(value.front);
else
ls.front.opIndexOpAssignImplSlice!op(value.front);
value.popFront;
}
ls.popFront;
}
while (ls._lengths[0]);
}
}
/++
Assignment of a value of `Slice` type to a $(B fully defined slice).
+/
auto opIndexAssign(RIterator, size_t RN, SliceKind rkind, Slices...)
(scope Slice!(RIterator, RN, rkind) value, Slices slices) scope return
if (isFullPureSlice!Slices || isIndexedSlice!Slices)
{
auto sl = this[slices];
assert(_checkAssignLengths(sl, value));
if(!sl.anyRUEmpty)
sl.opIndexOpAssignImplSlice!""(value);
return sl;
}
static if (doUnittest)
///
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
auto a = slice!int(2, 3);
auto b = [1, 2, 3, 4].sliced(2, 2);
a[0..$, 0..$-1] = b;
assert(a == [[1, 2, 0], [3, 4, 0]]);
// fills both rows with b[0]
a[0..$, 0..$-1] = b[0];
assert(a == [[1, 2, 0], [1, 2, 0]]);
a[1, 0..$-1] = b[1];
assert(a[1] == [3, 4, 0]);
a[1, 0..$-1][] = b[0];
assert(a[1] == [1, 2, 0]);
}
static if (doUnittest)
/// Left slice is packed
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : blocks, iota;
import mir.ndslice.allocation : slice;
auto a = slice!int(4, 4);
a.blocks(2, 2)[] = iota!int(2, 2);
assert(a ==
[[0, 0, 1, 1],
[0, 0, 1, 1],
[2, 2, 3, 3],
[2, 2, 3, 3]]);
}
static if (doUnittest)
/// Both slices are packed
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : blocks, iota, pack;
import mir.ndslice.allocation : slice;
auto a = slice!int(4, 4);
a.blocks(2, 2)[] = iota!int(2, 2, 2).pack!1;
assert(a ==
[[0, 1, 2, 3],
[0, 1, 2, 3],
[4, 5, 6, 7],
[4, 5, 6, 7]]);
}
void opIndexOpAssignImplArray(string op, T, Slices...)(T[] value) scope
{
auto ls = this;
assert(ls.length == value.length, __FUNCTION__ ~ ": argument must have the same length.");
static if (N == 1)
{
do
{
static if (ls.N == 1)
{
static if (isInstanceOf!(SliceIterator, Iterator))
{
static if (isSlice!(typeof(value[0])))
ls.front.opIndexOpAssignImplSlice!op(value[0]);
else
static if (isDynamicArray!(typeof(value[0])))
ls.front.opIndexOpAssignImplSlice!op(value[0]);
else
ls.front.opIndexOpAssignImplValue!op(value[0]);
}
else
static if (op == "^^" && isFloatingPoint!(typeof(ls.front)) && isFloatingPoint!(typeof(value[0])))
{
import mir.math.common: pow;
ls.front = pow(ls.front, value[0]);
}
else
mixin("ls.front " ~ op ~ "= value[0];");
}
else
mixin("ls.front[] " ~ op ~ "= value[0];");
value = value[1 .. $];
ls.popFront;
}
while (ls.length);
}
else
static if (N == DynamicArrayDimensionsCount!(T[]))
{
do
{
ls.front.opIndexOpAssignImplArray!op(value[0]);
value = value[1 .. $];
ls.popFront;
}
while (ls.length);
}
else
{
do
{
ls.front.opIndexOpAssignImplArray!op(value);
ls.popFront;
}
while (ls.length);
}
}
/++
Assignment of a regular multidimensional array to a $(B fully defined slice).
+/
auto opIndexAssign(T, Slices...)(T[] value, Slices slices) scope return
if ((isFullPureSlice!Slices || isIndexedSlice!Slices)
&& !isDynamicArray!DeepElement
&& DynamicArrayDimensionsCount!(T[]) <= typeof(this[slices]).N)
{
auto sl = this[slices];
sl.opIndexOpAssignImplArray!""(value);
return sl;
}
static if (doUnittest)
///
pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
auto a = slice!int(2, 3);
auto b = [[1, 2], [3, 4]];
a[] = [[1, 2, 3], [4, 5, 6]];
assert(a == [[1, 2, 3], [4, 5, 6]]);
a[0..$, 0..$-1] = [[1, 2], [3, 4]];
assert(a == [[1, 2, 3], [3, 4, 6]]);
a[0..$, 0..$-1] = [1, 2];
assert(a == [[1, 2, 3], [1, 2, 6]]);
a[1, 0..$-1] = [3, 4];
assert(a[1] == [3, 4, 6]);
a[1, 0..$-1][] = [3, 4];
assert(a[1] == [3, 4, 6]);
}
static if (doUnittest)
/// Packed slices
pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation : slice;
import mir.ndslice.topology : blocks;
auto a = slice!int(4, 4);
a.blocks(2, 2)[] = [[0, 1], [2, 3]];
assert(a ==
[[0, 0, 1, 1],
[0, 0, 1, 1],
[2, 2, 3, 3],
[2, 2, 3, 3]]);
}
private void opIndexOpAssignImplConcatenation(string op, T)(T value) scope
{
auto sl = this;
static if (concatenationDimension!T)
{
if (!sl.empty) do
{
static if (op == "")
sl.front.opIndexAssign(value.front);
else
sl.front.opIndexOpAssign!op(value.front);
value.popFront;
sl.popFront;
}
while(!sl.empty);
}
else
{
foreach (ref slice; value._slices)
{
static if (op == "")
sl[0 .. slice.length].opIndexAssign(slice);
else
sl[0 .. slice.length].opIndexOpAssign!op(slice);
sl = sl[slice.length .. $];
}
assert(sl.empty);
}
}
///
auto opIndexAssign(T, Slices...)(T concatenation, Slices slices) scope return
if ((isFullPureSlice!Slices || isIndexedSlice!Slices) && isConcatenation!T)
{
auto sl = this[slices];
static assert(typeof(sl).N == T.N, "incompatible dimension count");
sl.opIndexOpAssignImplConcatenation!""(concatenation);
return sl;
}
/++
Assignment of a value (e.g. a number) to a $(B fully defined slice).
+/
auto opIndexAssign(T, Slices...)(T value, Slices slices) scope return
if ((isFullPureSlice!Slices || isIndexedSlice!Slices)
&& (!isDynamicArray!T || isDynamicArray!DeepElement)
&& !isSlice!T
&& !isConcatenation!T)
{
auto sl = this[slices];
if(!sl.anyRUEmpty)
sl.opIndexOpAssignImplValue!""(value);
return sl;
}
static if (doUnittest)
///
@safe pure nothrow
version(mir_test) unittest
{
import mir.ndslice.allocation;
auto a = slice!int(2, 3);
a[] = 9;
assert(a == [[9, 9, 9], [9, 9, 9]]);
a[0..$, 0..$-1] = 1;
assert(a == [[1, 1, 9], [1, 1, 9]]);
a[0..$, 0..$-1] = 2;
assert(a == [[2, 2, 9], [2, 2, 9]]);
a[1, 0..$-1] = 3;
//assert(a[1] == [3, 3, 9]);
a[1, 0..$-1] = 4;
//assert(a[1] == [4, 4, 9]);
a[1, 0..$-1][] = 5;
assert(a[1] == [5, 5, 9]);
}
static if (doUnittest)
/// Packed slices have the same behavior.
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
import mir.ndslice.topology : pack;
auto a = slice!int(2, 3).pack!1;
a[] = 9;
//assert(a == [[9, 9, 9], [9, 9, 9]]);
}
/++
Assignment of a value (e.g. a number) to a $(B fully defined index).
+/
auto ref opIndexAssign(T)(T value, size_t[N] _indexes...) scope return @trusted
{
// check assign safety
static auto ref fun(ref DeepElement t, ref T v) @safe
{
return t = v;
}
return _iterator[indexStride(_indexes)] = value;
}
static if (doUnittest)
///
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
auto a = slice!int(2, 3);
a[1, 2] = 3;
assert(a[1, 2] == 3);
}
static if (doUnittest)
@safe pure nothrow version(mir_test) unittest
{
auto a = new int[6].sliced(2, 3);
a[[1, 2]] = 3;
assert(a[[1, 2]] == 3);
}
/++
Op Assignment `op=` of a value (e.g. a number) to a $(B fully defined index).
+/
auto ref opIndexOpAssign(string op, T)(T value, size_t[N] _indexes...) scope return @trusted
{
// check op safety
static auto ref fun(ref DeepElement t, ref T v) @safe
{
return mixin(`t` ~ op ~ `= v`);
}
auto str = indexStride(_indexes);
static if (op == "^^" && isFloatingPoint!DeepElement && isFloatingPoint!(typeof(value)))
{
import mir.math.common: pow;
_iterator[str] = pow(_iterator[str], value);
}
else
return mixin (`_iterator[str] ` ~ op ~ `= value`);
}
static if (doUnittest)
///
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
auto a = slice!int(2, 3);
a[1, 2] += 3;
assert(a[1, 2] == 3);
}
static if (doUnittest)
@safe pure nothrow version(mir_test) unittest
{
auto a = new int[6].sliced(2, 3);
a[[1, 2]] += 3;
assert(a[[1, 2]] == 3);
}
/++
Op Assignment `op=` of a value of `Slice` type to a $(B fully defined slice).
+/
auto opIndexOpAssign(string op, RIterator, SliceKind rkind, size_t RN, Slices...)
(Slice!(RIterator, RN, rkind) value, Slices slices) scope return
if (isFullPureSlice!Slices || isIndexedSlice!Slices)
{
auto sl = this[slices];
assert(_checkAssignLengths(sl, value));
if(!sl.anyRUEmpty)
sl.opIndexOpAssignImplSlice!op(value);
return sl;
}
static if (doUnittest)
///
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
auto a = slice!int(2, 3);
auto b = [1, 2, 3, 4].sliced(2, 2);
a[0..$, 0..$-1] += b;
assert(a == [[1, 2, 0], [3, 4, 0]]);
a[0..$, 0..$-1] += b[0];
assert(a == [[2, 4, 0], [4, 6, 0]]);
a[1, 0..$-1] += b[1];
assert(a[1] == [7, 10, 0]);
a[1, 0..$-1][] += b[0];
assert(a[1] == [8, 12, 0]);
}
static if (doUnittest)
/// Left slice is packed
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation : slice;
import mir.ndslice.topology : blocks, iota;
auto a = slice!size_t(4, 4);
a.blocks(2, 2)[] += iota(2, 2);
assert(a ==
[[0, 0, 1, 1],
[0, 0, 1, 1],
[2, 2, 3, 3],
[2, 2, 3, 3]]);
}
static if (doUnittest)
/// Both slices are packed
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation : slice;
import mir.ndslice.topology : blocks, iota, pack;
auto a = slice!size_t(4, 4);
a.blocks(2, 2)[] += iota(2, 2, 2).pack!1;
assert(a ==
[[0, 1, 2, 3],
[0, 1, 2, 3],
[4, 5, 6, 7],
[4, 5, 6, 7]]);
}
/++
Op Assignment `op=` of a regular multidimensional array to a $(B fully defined slice).
+/
auto opIndexOpAssign(string op, T, Slices...)(T[] value, Slices slices) scope return
if (isFullPureSlice!Slices
&& !isDynamicArray!DeepElement
&& DynamicArrayDimensionsCount!(T[]) <= typeof(this[slices]).N)
{
auto sl = this[slices];
sl.opIndexOpAssignImplArray!op(value);
return sl;
}
static if (doUnittest)
///
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation : slice;
auto a = slice!int(2, 3);
a[0..$, 0..$-1] += [[1, 2], [3, 4]];
assert(a == [[1, 2, 0], [3, 4, 0]]);
a[0..$, 0..$-1] += [1, 2];
assert(a == [[2, 4, 0], [4, 6, 0]]);
a[1, 0..$-1] += [3, 4];
assert(a[1] == [7, 10, 0]);
a[1, 0..$-1][] += [1, 2];
assert(a[1] == [8, 12, 0]);
}
static if (doUnittest)
/// Packed slices
@safe pure nothrow
version(mir_test) unittest
{
import mir.ndslice.allocation : slice;
import mir.ndslice.topology : blocks;
auto a = slice!int(4, 4);
a.blocks(2, 2)[].opIndexOpAssign!"+"([[0, 1], [2, 3]]);
assert(a ==
[[0, 0, 1, 1],
[0, 0, 1, 1],
[2, 2, 3, 3],
[2, 2, 3, 3]]);
}
private void opIndexOpAssignImplValue(string op, T)(T value) scope return
{
static if (N > 1 && kind == Contiguous)
{
import mir.ndslice.topology : flattened;
this.flattened.opIndexOpAssignImplValue!op(value);
}
else
{
auto ls = this;
do
{
static if (N == 1)
{
static if (isInstanceOf!(SliceIterator, Iterator))
ls.front.opIndexOpAssignImplValue!op(value);
else
mixin (`ls.front ` ~ op ~ `= value;`);
}
else
ls.front.opIndexOpAssignImplValue!op(value);
ls.popFront;
}
while(ls._lengths[0]);
}
}
/++
Op Assignment `op=` of a value (e.g. a number) to a $(B fully defined slice).
+/
auto opIndexOpAssign(string op, T, Slices...)(T value, Slices slices) scope return
if ((isFullPureSlice!Slices || isIndexedSlice!Slices)
&& (!isDynamicArray!T || isDynamicArray!DeepElement)
&& !isSlice!T
&& !isConcatenation!T)
{
auto sl = this[slices];
if(!sl.anyRUEmpty)
sl.opIndexOpAssignImplValue!op(value);
return sl;
}
static if (doUnittest)
///
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
auto a = slice!int(2, 3);
a[] += 1;
assert(a == [[1, 1, 1], [1, 1, 1]]);
a[0..$, 0..$-1] += 2;
assert(a == [[3, 3, 1], [3, 3, 1]]);
a[1, 0..$-1] += 3;
assert(a[1] == [6, 6, 1]);
}
///
auto opIndexOpAssign(string op,T, Slices...)(T concatenation, Slices slices) scope return
if ((isFullPureSlice!Slices || isIndexedSlice!Slices) && isConcatenation!T)
{
auto sl = this[slices];
static assert(typeof(sl).N == concatenation.N);
sl.opIndexOpAssignImplConcatenation!op(concatenation);
return sl;
}
static if (doUnittest)
/// Packed slices have the same behavior.
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
import mir.ndslice.topology : pack;
auto a = slice!int(2, 3).pack!1;
a[] += 9;
assert(a == [[9, 9, 9], [9, 9, 9]]);
}
/++
Increment `++` and Decrement `--` operators for a $(B fully defined index).
+/
auto ref opIndexUnary(string op)(size_t[N] _indexes...) scope return
@trusted
// @@@workaround@@@ for Issue 16473
//if (op == `++` || op == `--`)
{
// check op safety
static auto ref fun(DeepElement t) @safe
{
return mixin(op ~ `t`);
}
return mixin (op ~ `_iterator[indexStride(_indexes)]`);
}
static if (doUnittest)
///
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
auto a = slice!int(2, 3);
++a[1, 2];
assert(a[1, 2] == 1);
}
// Issue 16473
static if (doUnittest)
@safe pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
auto sl = slice!double(2, 5);
auto d = -sl[0, 1];
}
static if (doUnittest)
@safe pure nothrow version(mir_test) unittest
{
auto a = new int[6].sliced(2, 3);
++a[[1, 2]];
assert(a[[1, 2]] == 1);
}
private void opIndexUnaryImpl(string op, Slices...)(Slices slices) scope
{
auto ls = this;
do
{
static if (N == 1)
{
static if (isInstanceOf!(SliceIterator, Iterator))
ls.front.opIndexUnaryImpl!op;
else
mixin (op ~ `ls.front;`);
}
else
ls.front.opIndexUnaryImpl!op;
ls.popFront;
}
while(ls._lengths[0]);
}
/++
Increment `++` and Decrement `--` operators for a $(B fully defined slice).
+/
void opIndexUnary(string op, Slices...)(Slices slices) scope return
if (isFullPureSlice!Slices && (op == `++` || op == `--`))
{
auto sl = this[slices];
if (!sl.anyRUEmpty)
sl.opIndexUnaryImpl!op;
}
static if (doUnittest)
///
@safe pure nothrow
version(mir_test) unittest
{
import mir.ndslice.allocation;
auto a = slice!int(2, 3);
++a[];
assert(a == [[1, 1, 1], [1, 1, 1]]);
--a[1, 0..$-1];
assert(a[1] == [0, 0, 1]);
}
}
}
/// ditto
alias Slice = mir_slice;
/++
Slicing, indexing, and arithmetic operations.
+/
pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
import mir.ndslice.dynamic : transposed;
import mir.ndslice.topology : iota, universal;
auto tensor = iota(3, 4, 5).slice;
assert(tensor[1, 2] == tensor[1][2]);
assert(tensor[1, 2, 3] == tensor[1][2][3]);
assert( tensor[0..$, 0..$, 4] == tensor.universal.transposed!2[4]);
assert(&tensor[0..$, 0..$, 4][1, 2] is &tensor[1, 2, 4]);
tensor[1, 2, 3]++; //`opIndex` returns value by reference.
--tensor[1, 2, 3]; //`opUnary`
++tensor[];
tensor[] -= 1;
// `opIndexAssing` accepts only fully defined indexes and slices.
// Use an additional empty slice `[]`.
static assert(!__traits(compiles, tensor[0 .. 2] *= 2));
tensor[0 .. 2][] *= 2; //OK, empty slice
tensor[0 .. 2, 3, 0..$] /= 2; //OK, 3 index or slice positions are defined.
//fully defined index may be replaced by a static array
size_t[3] index = [1, 2, 3];
assert(tensor[index] == tensor[1, 2, 3]);
}
/++
Operations with rvalue slices.
+/
pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
import mir.ndslice.topology: universal;
import mir.ndslice.dynamic: transposed, everted;
auto tensor = slice!int(3, 4, 5).universal;
auto matrix = slice!int(3, 4).universal;
auto vector = slice!int(3);
foreach (i; 0..3)
vector[i] = i;
// fills matrix columns
matrix.transposed[] = vector;
// fills tensor with vector
// transposed tensor shape is (4, 5, 3)
// vector shape is ( 3)
tensor.transposed!(1, 2)[] = vector;
// transposed tensor shape is (5, 3, 4)
// matrix shape is ( 3, 4)
tensor.transposed!2[] += matrix;
// transposed tensor shape is (5, 4, 3)
// transposed matrix shape is ( 4, 3)
tensor.everted[] ^= matrix.transposed; // XOR
}
/++
Creating a slice from text.
See also $(MREF std, format).
+/
version(mir_test) unittest
{
import mir.ndslice.allocation;
import std.algorithm, std.conv, std.exception, std.format,
std.functional, std.string, std.range;
Slice!(int*, 2) toMatrix(string str)
{
string[][] data = str.lineSplitter.filter!(not!empty).map!split.array;
size_t rows = data .length.enforce("empty input");
size_t columns = data[0].length.enforce("empty first row");
data.each!(a => enforce(a.length == columns, "rows have different lengths"));
auto slice = slice!int(rows, columns);
foreach (i, line; data)
foreach (j, num; line)
slice[i, j] = num.to!int;
return slice;
}
auto input = "\r1 2 3\r\n 4 5 6\n";
auto matrix = toMatrix(input);
assert(matrix == [[1, 2, 3], [4, 5, 6]]);
// back to text
auto text2 = format("%(%(%s %)\n%)\n", matrix);
assert(text2 == "1 2 3\n4 5 6\n");
}
// Slicing
@safe @nogc pure nothrow version(mir_test) unittest
{
import mir.ndslice.topology : iota;
auto a = iota(10, 20, 30, 40);
auto b = a[0..$, 10, 4 .. 27, 4];
auto c = b[2 .. 9, 5 .. 10];
auto d = b[3..$, $-2];
assert(b[4, 17] == a[4, 10, 21, 4]);
assert(c[1, 2] == a[3, 10, 11, 4]);
assert(d[3] == a[6, 10, 25, 4]);
}
// Operator overloading. # 1
pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
import mir.ndslice.topology : iota;
auto fun(ref sizediff_t x) { x *= 3; }
auto tensor = iota(8, 9, 10).slice;
++tensor[];
fun(tensor[0, 0, 0]);
assert(tensor[0, 0, 0] == 3);
tensor[0, 0, 0] *= 4;
tensor[0, 0, 0]--;
assert(tensor[0, 0, 0] == 11);
}
// Operator overloading. # 2
pure nothrow version(mir_test) unittest
{
import std.algorithm.iteration : map;
import mir.array.allocation : array;
//import std.bigint;
import std.range : iota;
auto matrix = 72
.iota
//.map!(i => BigInt(i))
.array
.sliced(8, 9);
matrix[3 .. 6, 2] += 100;
foreach (i; 0 .. 8)
foreach (j; 0 .. 9)
if (i >= 3 && i < 6 && j == 2)
assert(matrix[i, j] >= 100);
else
assert(matrix[i, j] < 100);
}
// Operator overloading. # 3
pure nothrow version(mir_test) unittest
{
import mir.ndslice.allocation;
import mir.ndslice.topology : iota;
auto matrix = iota(8, 9).slice;
matrix[] = matrix;
matrix[] += matrix;
assert(matrix[2, 3] == (2 * 9 + 3) * 2);
auto vec = iota([9], 100);
matrix[] = vec;
foreach (v; matrix)
assert(v == vec);
matrix[] += vec;
foreach (vector; matrix)
foreach (elem; vector)
assert(elem >= 200);
}
// Type deduction
version(mir_test) unittest
{
// Arrays
foreach (T; AliasSeq!(int, const int, immutable int))
static assert(is(typeof((T[]).init.sliced(3, 4)) == Slice!(T*, 2)));
// Container Array
import std.container.array;
Array!int ar;
ar.length = 12;
auto arSl = ar[].slicedField(3, 4);
}
// Test for map #1
version(mir_test) unittest
{
import std.algorithm.iteration : map;
import std.range.primitives;
auto slice = [1, 2, 3, 4].sliced(2, 2);
auto r = slice.map!(a => a.map!(a => a * 6));
assert(r.front.front == 6);
assert(r.front.back == 12);
assert(r.back.front == 18);
assert(r.back.back == 24);
assert(r[0][0] == 6);
assert(r[0][1] == 12);
assert(r[1][0] == 18);
assert(r[1][1] == 24);
static assert(hasSlicing!(typeof(r)));
static assert(isForwardRange!(typeof(r)));
static assert(isRandomAccessRange!(typeof(r)));
}
// Test for map #2
version(mir_test) unittest
{
import std.algorithm.iteration : map;
import std.range.primitives;
auto data = [1, 2, 3, 4]
//.map!(a => a * 2)
;
static assert(hasSlicing!(typeof(data)));
static assert(isForwardRange!(typeof(data)));
static assert(isRandomAccessRange!(typeof(data)));
auto slice = data.sliced(2, 2);
static assert(hasSlicing!(typeof(slice)));
static assert(isForwardRange!(typeof(slice)));
static assert(isRandomAccessRange!(typeof(slice)));
auto r = slice.map!(a => a.map!(a => a * 6));
static assert(hasSlicing!(typeof(r)));
static assert(isForwardRange!(typeof(r)));
static assert(isRandomAccessRange!(typeof(r)));
assert(r.front.front == 6);
assert(r.front.back == 12);
assert(r.back.front == 18);
assert(r.back.back == 24);
assert(r[0][0] == 6);
assert(r[0][1] == 12);
assert(r[1][0] == 18);
assert(r[1][1] == 24);
}
private enum bool isType(alias T) = false;
private enum bool isType(T) = true;
private enum isStringValue(alias T) = is(typeof(T) : string);
private bool _checkAssignLengths(
LIterator, RIterator,
size_t LN, size_t RN,
SliceKind lkind, SliceKind rkind,
)
(scope Slice!(LIterator, LN, lkind) ls,
scope Slice!(RIterator, RN, rkind) rs)
{
static if (isInstanceOf!(SliceIterator, LIterator))
{
import mir.ndslice.topology: unpack;
return _checkAssignLengths(ls.unpack, rs);
}
else
static if (isInstanceOf!(SliceIterator, RIterator))
{
import mir.ndslice.topology: unpack;
return _checkAssignLengths(ls, rs.unpack);
}
else
{
foreach (i; Iota!(0, RN))
if (ls._lengths[i + LN - RN] != rs._lengths[i])
return false;
return true;
}
}
@safe pure nothrow @nogc version(mir_test) unittest
{
import mir.ndslice.topology : iota;
assert(_checkAssignLengths(iota(2, 2), iota(2, 2)));
assert(!_checkAssignLengths(iota(2, 2), iota(2, 3)));
assert(!_checkAssignLengths(iota(2, 2), iota(3, 2)));
assert(!_checkAssignLengths(iota(2, 2), iota(3, 3)));
}
pure nothrow version(mir_test) unittest
{
auto slice = new int[15].slicedField(5, 3);
/// Fully defined slice
assert(slice[] == slice);
auto sublice = slice[0..$-2, 1..$];
/// Partially defined slice
auto row = slice[3];
auto col = slice[0..$, 1];
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
auto b = [1, 2, 3, 4].sliced(2, 2);
a[0..$, 0..$-1] = b;
assert(a == [[1, 2, 0], [3, 4, 0]]);
a[0..$, 0..$-1] = b[0];
assert(a == [[1, 2, 0], [1, 2, 0]]);
a[1, 0..$-1] = b[1];
assert(a[1] == [3, 4, 0]);
a[1, 0..$-1][] = b[0];
assert(a[1] == [1, 2, 0]);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
auto b = [[1, 2], [3, 4]];
a[] = [[1, 2, 3], [4, 5, 6]];
assert(a == [[1, 2, 3], [4, 5, 6]]);
a[0..$, 0..$-1] = [[1, 2], [3, 4]];
assert(a == [[1, 2, 3], [3, 4, 6]]);
a[0..$, 0..$-1] = [1, 2];
assert(a == [[1, 2, 3], [1, 2, 6]]);
a[1, 0..$-1] = [3, 4];
assert(a[1] == [3, 4, 6]);
a[1, 0..$-1][] = [3, 4];
assert(a[1] == [3, 4, 6]);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
a[] = 9;
//assert(a == [[9, 9, 9], [9, 9, 9]]);
a[0..$, 0..$-1] = 1;
//assert(a == [[1, 1, 9], [1, 1, 9]]);
a[0..$, 0..$-1] = 2;
//assert(a == [[2, 2, 9], [2, 2, 9]]);
a[1, 0..$-1] = 3;
//assert(a[1] == [3, 3, 9]);
a[1, 0..$-1] = 4;
//assert(a[1] == [4, 4, 9]);
a[1, 0..$-1][] = 5;
//assert(a[1] == [5, 5, 9]);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
a[1, 2] = 3;
assert(a[1, 2] == 3);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
a[[1, 2]] = 3;
assert(a[[1, 2]] == 3);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
a[1, 2] += 3;
assert(a[1, 2] == 3);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
a[[1, 2]] += 3;
assert(a[[1, 2]] == 3);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
auto b = [1, 2, 3, 4].sliced(2, 2);
a[0..$, 0..$-1] += b;
assert(a == [[1, 2, 0], [3, 4, 0]]);
a[0..$, 0..$-1] += b[0];
assert(a == [[2, 4, 0], [4, 6, 0]]);
a[1, 0..$-1] += b[1];
assert(a[1] == [7, 10, 0]);
a[1, 0..$-1][] += b[0];
assert(a[1] == [8, 12, 0]);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
a[0..$, 0..$-1] += [[1, 2], [3, 4]];
assert(a == [[1, 2, 0], [3, 4, 0]]);
a[0..$, 0..$-1] += [1, 2];
assert(a == [[2, 4, 0], [4, 6, 0]]);
a[1, 0..$-1] += [3, 4];
assert(a[1] == [7, 10, 0]);
a[1, 0..$-1][] += [1, 2];
assert(a[1] == [8, 12, 0]);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
a[] += 1;
assert(a == [[1, 1, 1], [1, 1, 1]]);
a[0..$, 0..$-1] += 2;
assert(a == [[3, 3, 1], [3, 3, 1]]);
a[1, 0..$-1] += 3;
assert(a[1] == [6, 6, 1]);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
++a[1, 2];
assert(a[1, 2] == 1);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
++a[[1, 2]];
assert(a[[1, 2]] == 1);
}
pure nothrow version(mir_test) unittest
{
auto a = new int[6].slicedField(2, 3);
++a[];
assert(a == [[1, 1, 1], [1, 1, 1]]);
--a[1, 0..$-1];
assert(a[1] == [0, 0, 1]);
}
version(mir_test) unittest
{
import mir.ndslice.topology: iota, universal;
auto sl = iota(3, 4).universal;
assert(sl[0 .. $] == sl);
}
version(mir_test) unittest
{
import mir.ndslice.topology: canonical, iota;
static assert(kindOf!(typeof(iota([1, 2]).canonical[1])) == Contiguous);
}
version(mir_test) unittest
{
import mir.ndslice.topology: iota;
auto s = iota(2, 3);
assert(s.front!1 == [0, 3]);
assert(s.back!1 == [2, 5]);
}
/++
Assignment utility for generic code that works both with scalars and with ndslices.
Params:
op = assign operation (generic, optional)
lside = left side
rside = right side
Returns:
expression value
+/
auto ndassign(string op = "", L, R)(ref L lside, auto ref R rside) @property
if (!isSlice!L && (op.length == 0 || op[$-1] != '='))
{
return mixin(`lside ` ~ op ~ `= rside`);
}
/// ditto
auto ndassign(string op = "", L, R)(L lside, auto ref R rside) @property
if (isSlice!L && (op.length == 0 || op[$-1] != '='))
{
static if (op == "")
return lside.opIndexAssign(rside);
else
return lside.opIndexOpAssign!op(rside);
}
///
version(mir_test) unittest
{
import mir.ndslice.topology: iota;
import mir.ndslice.allocation: slice;
auto scalar = 3;
auto vector = 3.iota.slice; // [0, 1, 2]
// scalar = 5;
scalar.ndassign = 5;
assert(scalar == 5);
// vector[] = vector * 2;
vector.ndassign = vector * 2;
assert(vector == [0, 2, 4]);
// vector[] += scalar;
vector.ndassign!"+"= scalar;
assert(vector == [5, 7, 9]);
}
|
D
|
module capstone.sparc;
extern (C):
/* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2014-2015 */
// GCC SPARC toolchain has a default macro called "sparc" which breaks
// compilation
/// Enums corresponding to Sparc condition codes, both icc's and fcc's.
enum sparc_cc
{
SPARC_CC_INVALID = 0, ///< invalid CC (default)
// Integer condition codes
SPARC_CC_ICC_A = 8 + 256, ///< Always
SPARC_CC_ICC_N = 0 + 256, ///< Never
SPARC_CC_ICC_NE = 9 + 256, ///< Not Equal
SPARC_CC_ICC_E = 1 + 256, ///< Equal
SPARC_CC_ICC_G = 10 + 256, ///< Greater
SPARC_CC_ICC_LE = 2 + 256, ///< Less or Equal
SPARC_CC_ICC_GE = 11 + 256, ///< Greater or Equal
SPARC_CC_ICC_L = 3 + 256, ///< Less
SPARC_CC_ICC_GU = 12 + 256, ///< Greater Unsigned
SPARC_CC_ICC_LEU = 4 + 256, ///< Less or Equal Unsigned
SPARC_CC_ICC_CC = 13 + 256, ///< Carry Clear/Great or Equal Unsigned
SPARC_CC_ICC_CS = 5 + 256, ///< Carry Set/Less Unsigned
SPARC_CC_ICC_POS = 14 + 256, ///< Positive
SPARC_CC_ICC_NEG = 6 + 256, ///< Negative
SPARC_CC_ICC_VC = 15 + 256, ///< Overflow Clear
SPARC_CC_ICC_VS = 7 + 256, ///< Overflow Set
// Floating condition codes
SPARC_CC_FCC_A = 8 + 16 + 256, ///< Always
SPARC_CC_FCC_N = 0 + 16 + 256, ///< Never
SPARC_CC_FCC_U = 7 + 16 + 256, ///< Unordered
SPARC_CC_FCC_G = 6 + 16 + 256, ///< Greater
SPARC_CC_FCC_UG = 5 + 16 + 256, ///< Unordered or Greater
SPARC_CC_FCC_L = 4 + 16 + 256, ///< Less
SPARC_CC_FCC_UL = 3 + 16 + 256, ///< Unordered or Less
SPARC_CC_FCC_LG = 2 + 16 + 256, ///< Less or Greater
SPARC_CC_FCC_NE = 1 + 16 + 256, ///< Not Equal
SPARC_CC_FCC_E = 9 + 16 + 256, ///< Equal
SPARC_CC_FCC_UE = 10 + 16 + 256, ///< Unordered or Equal
SPARC_CC_FCC_GE = 11 + 16 + 256, ///< Greater or Equal
SPARC_CC_FCC_UGE = 12 + 16 + 256, ///< Unordered or Greater or Equal
SPARC_CC_FCC_LE = 13 + 16 + 256, ///< Less or Equal
SPARC_CC_FCC_ULE = 14 + 16 + 256, ///< Unordered or Less or Equal
SPARC_CC_FCC_O = 15 + 16 + 256 ///< Ordered
}
/// Branch hint
enum sparc_hint
{
SPARC_HINT_INVALID = 0, ///< no hint
SPARC_HINT_A = 1 << 0, ///< annul delay slot instruction
SPARC_HINT_PT = 1 << 1, ///< branch taken
SPARC_HINT_PN = 1 << 2 ///< branch NOT taken
}
/// Operand type for instruction's operands
enum sparc_op_type
{
SPARC_OP_INVALID = 0, ///< = CS_OP_INVALID (Uninitialized).
SPARC_OP_REG = 1, ///< = CS_OP_REG (Register operand).
SPARC_OP_IMM = 2, ///< = CS_OP_IMM (Immediate operand).
SPARC_OP_MEM = 3 ///< = CS_OP_MEM (Memory operand).
}
/// SPARC registers
enum sparc_reg
{
SPARC_REG_INVALID = 0,
SPARC_REG_F0 = 1,
SPARC_REG_F1 = 2,
SPARC_REG_F2 = 3,
SPARC_REG_F3 = 4,
SPARC_REG_F4 = 5,
SPARC_REG_F5 = 6,
SPARC_REG_F6 = 7,
SPARC_REG_F7 = 8,
SPARC_REG_F8 = 9,
SPARC_REG_F9 = 10,
SPARC_REG_F10 = 11,
SPARC_REG_F11 = 12,
SPARC_REG_F12 = 13,
SPARC_REG_F13 = 14,
SPARC_REG_F14 = 15,
SPARC_REG_F15 = 16,
SPARC_REG_F16 = 17,
SPARC_REG_F17 = 18,
SPARC_REG_F18 = 19,
SPARC_REG_F19 = 20,
SPARC_REG_F20 = 21,
SPARC_REG_F21 = 22,
SPARC_REG_F22 = 23,
SPARC_REG_F23 = 24,
SPARC_REG_F24 = 25,
SPARC_REG_F25 = 26,
SPARC_REG_F26 = 27,
SPARC_REG_F27 = 28,
SPARC_REG_F28 = 29,
SPARC_REG_F29 = 30,
SPARC_REG_F30 = 31,
SPARC_REG_F31 = 32,
SPARC_REG_F32 = 33,
SPARC_REG_F34 = 34,
SPARC_REG_F36 = 35,
SPARC_REG_F38 = 36,
SPARC_REG_F40 = 37,
SPARC_REG_F42 = 38,
SPARC_REG_F44 = 39,
SPARC_REG_F46 = 40,
SPARC_REG_F48 = 41,
SPARC_REG_F50 = 42,
SPARC_REG_F52 = 43,
SPARC_REG_F54 = 44,
SPARC_REG_F56 = 45,
SPARC_REG_F58 = 46,
SPARC_REG_F60 = 47,
SPARC_REG_F62 = 48,
SPARC_REG_FCC0 = 49, // Floating condition codes
SPARC_REG_FCC1 = 50,
SPARC_REG_FCC2 = 51,
SPARC_REG_FCC3 = 52,
SPARC_REG_FP = 53,
SPARC_REG_G0 = 54,
SPARC_REG_G1 = 55,
SPARC_REG_G2 = 56,
SPARC_REG_G3 = 57,
SPARC_REG_G4 = 58,
SPARC_REG_G5 = 59,
SPARC_REG_G6 = 60,
SPARC_REG_G7 = 61,
SPARC_REG_I0 = 62,
SPARC_REG_I1 = 63,
SPARC_REG_I2 = 64,
SPARC_REG_I3 = 65,
SPARC_REG_I4 = 66,
SPARC_REG_I5 = 67,
SPARC_REG_I7 = 68,
SPARC_REG_ICC = 69, // Integer condition codes
SPARC_REG_L0 = 70,
SPARC_REG_L1 = 71,
SPARC_REG_L2 = 72,
SPARC_REG_L3 = 73,
SPARC_REG_L4 = 74,
SPARC_REG_L5 = 75,
SPARC_REG_L6 = 76,
SPARC_REG_L7 = 77,
SPARC_REG_O0 = 78,
SPARC_REG_O1 = 79,
SPARC_REG_O2 = 80,
SPARC_REG_O3 = 81,
SPARC_REG_O4 = 82,
SPARC_REG_O5 = 83,
SPARC_REG_O7 = 84,
SPARC_REG_SP = 85,
SPARC_REG_Y = 86,
// special register
SPARC_REG_XCC = 87,
SPARC_REG_ENDING = 88, // <-- mark the end of the list of registers
// extras
SPARC_REG_O6 = SPARC_REG_SP,
SPARC_REG_I6 = SPARC_REG_FP
}
/// Instruction's operand referring to memory
/// This is associated with SPARC_OP_MEM operand type above
struct sparc_op_mem
{
ubyte base; ///< base register, can be safely interpreted as
///< a value of type `sparc_reg`, but it is only
///< one byte wide
ubyte index; ///< index register, same conditions apply here
int disp; ///< displacement/offset value
}
/// Instruction operand
struct cs_sparc_op
{
sparc_op_type type; ///< operand type
union
{
sparc_reg reg; ///< register value for REG operand
long imm; ///< immediate value for IMM operand
sparc_op_mem mem; ///< base/disp value for MEM operand
}
}
/// Instruction structure
struct cs_sparc
{
sparc_cc cc; ///< code condition for this insn
sparc_hint hint; ///< branch hint: encoding as bitwise OR of sparc_hint.
/// Number of operands of this instruction,
/// or 0 when instruction has no operand.
ubyte op_count;
cs_sparc_op[4] operands; ///< operands for this instruction.
}
/// SPARC instruction
enum sparc_insn
{
SPARC_INS_INVALID = 0,
SPARC_INS_ADDCC = 1,
SPARC_INS_ADDX = 2,
SPARC_INS_ADDXCC = 3,
SPARC_INS_ADDXC = 4,
SPARC_INS_ADDXCCC = 5,
SPARC_INS_ADD = 6,
SPARC_INS_ALIGNADDR = 7,
SPARC_INS_ALIGNADDRL = 8,
SPARC_INS_ANDCC = 9,
SPARC_INS_ANDNCC = 10,
SPARC_INS_ANDN = 11,
SPARC_INS_AND = 12,
SPARC_INS_ARRAY16 = 13,
SPARC_INS_ARRAY32 = 14,
SPARC_INS_ARRAY8 = 15,
SPARC_INS_B = 16,
SPARC_INS_JMP = 17,
SPARC_INS_BMASK = 18,
SPARC_INS_FB = 19,
SPARC_INS_BRGEZ = 20,
SPARC_INS_BRGZ = 21,
SPARC_INS_BRLEZ = 22,
SPARC_INS_BRLZ = 23,
SPARC_INS_BRNZ = 24,
SPARC_INS_BRZ = 25,
SPARC_INS_BSHUFFLE = 26,
SPARC_INS_CALL = 27,
SPARC_INS_CASX = 28,
SPARC_INS_CAS = 29,
SPARC_INS_CMASK16 = 30,
SPARC_INS_CMASK32 = 31,
SPARC_INS_CMASK8 = 32,
SPARC_INS_CMP = 33,
SPARC_INS_EDGE16 = 34,
SPARC_INS_EDGE16L = 35,
SPARC_INS_EDGE16LN = 36,
SPARC_INS_EDGE16N = 37,
SPARC_INS_EDGE32 = 38,
SPARC_INS_EDGE32L = 39,
SPARC_INS_EDGE32LN = 40,
SPARC_INS_EDGE32N = 41,
SPARC_INS_EDGE8 = 42,
SPARC_INS_EDGE8L = 43,
SPARC_INS_EDGE8LN = 44,
SPARC_INS_EDGE8N = 45,
SPARC_INS_FABSD = 46,
SPARC_INS_FABSQ = 47,
SPARC_INS_FABSS = 48,
SPARC_INS_FADDD = 49,
SPARC_INS_FADDQ = 50,
SPARC_INS_FADDS = 51,
SPARC_INS_FALIGNDATA = 52,
SPARC_INS_FAND = 53,
SPARC_INS_FANDNOT1 = 54,
SPARC_INS_FANDNOT1S = 55,
SPARC_INS_FANDNOT2 = 56,
SPARC_INS_FANDNOT2S = 57,
SPARC_INS_FANDS = 58,
SPARC_INS_FCHKSM16 = 59,
SPARC_INS_FCMPD = 60,
SPARC_INS_FCMPEQ16 = 61,
SPARC_INS_FCMPEQ32 = 62,
SPARC_INS_FCMPGT16 = 63,
SPARC_INS_FCMPGT32 = 64,
SPARC_INS_FCMPLE16 = 65,
SPARC_INS_FCMPLE32 = 66,
SPARC_INS_FCMPNE16 = 67,
SPARC_INS_FCMPNE32 = 68,
SPARC_INS_FCMPQ = 69,
SPARC_INS_FCMPS = 70,
SPARC_INS_FDIVD = 71,
SPARC_INS_FDIVQ = 72,
SPARC_INS_FDIVS = 73,
SPARC_INS_FDMULQ = 74,
SPARC_INS_FDTOI = 75,
SPARC_INS_FDTOQ = 76,
SPARC_INS_FDTOS = 77,
SPARC_INS_FDTOX = 78,
SPARC_INS_FEXPAND = 79,
SPARC_INS_FHADDD = 80,
SPARC_INS_FHADDS = 81,
SPARC_INS_FHSUBD = 82,
SPARC_INS_FHSUBS = 83,
SPARC_INS_FITOD = 84,
SPARC_INS_FITOQ = 85,
SPARC_INS_FITOS = 86,
SPARC_INS_FLCMPD = 87,
SPARC_INS_FLCMPS = 88,
SPARC_INS_FLUSHW = 89,
SPARC_INS_FMEAN16 = 90,
SPARC_INS_FMOVD = 91,
SPARC_INS_FMOVQ = 92,
SPARC_INS_FMOVRDGEZ = 93,
SPARC_INS_FMOVRQGEZ = 94,
SPARC_INS_FMOVRSGEZ = 95,
SPARC_INS_FMOVRDGZ = 96,
SPARC_INS_FMOVRQGZ = 97,
SPARC_INS_FMOVRSGZ = 98,
SPARC_INS_FMOVRDLEZ = 99,
SPARC_INS_FMOVRQLEZ = 100,
SPARC_INS_FMOVRSLEZ = 101,
SPARC_INS_FMOVRDLZ = 102,
SPARC_INS_FMOVRQLZ = 103,
SPARC_INS_FMOVRSLZ = 104,
SPARC_INS_FMOVRDNZ = 105,
SPARC_INS_FMOVRQNZ = 106,
SPARC_INS_FMOVRSNZ = 107,
SPARC_INS_FMOVRDZ = 108,
SPARC_INS_FMOVRQZ = 109,
SPARC_INS_FMOVRSZ = 110,
SPARC_INS_FMOVS = 111,
SPARC_INS_FMUL8SUX16 = 112,
SPARC_INS_FMUL8ULX16 = 113,
SPARC_INS_FMUL8X16 = 114,
SPARC_INS_FMUL8X16AL = 115,
SPARC_INS_FMUL8X16AU = 116,
SPARC_INS_FMULD = 117,
SPARC_INS_FMULD8SUX16 = 118,
SPARC_INS_FMULD8ULX16 = 119,
SPARC_INS_FMULQ = 120,
SPARC_INS_FMULS = 121,
SPARC_INS_FNADDD = 122,
SPARC_INS_FNADDS = 123,
SPARC_INS_FNAND = 124,
SPARC_INS_FNANDS = 125,
SPARC_INS_FNEGD = 126,
SPARC_INS_FNEGQ = 127,
SPARC_INS_FNEGS = 128,
SPARC_INS_FNHADDD = 129,
SPARC_INS_FNHADDS = 130,
SPARC_INS_FNOR = 131,
SPARC_INS_FNORS = 132,
SPARC_INS_FNOT1 = 133,
SPARC_INS_FNOT1S = 134,
SPARC_INS_FNOT2 = 135,
SPARC_INS_FNOT2S = 136,
SPARC_INS_FONE = 137,
SPARC_INS_FONES = 138,
SPARC_INS_FOR = 139,
SPARC_INS_FORNOT1 = 140,
SPARC_INS_FORNOT1S = 141,
SPARC_INS_FORNOT2 = 142,
SPARC_INS_FORNOT2S = 143,
SPARC_INS_FORS = 144,
SPARC_INS_FPACK16 = 145,
SPARC_INS_FPACK32 = 146,
SPARC_INS_FPACKFIX = 147,
SPARC_INS_FPADD16 = 148,
SPARC_INS_FPADD16S = 149,
SPARC_INS_FPADD32 = 150,
SPARC_INS_FPADD32S = 151,
SPARC_INS_FPADD64 = 152,
SPARC_INS_FPMERGE = 153,
SPARC_INS_FPSUB16 = 154,
SPARC_INS_FPSUB16S = 155,
SPARC_INS_FPSUB32 = 156,
SPARC_INS_FPSUB32S = 157,
SPARC_INS_FQTOD = 158,
SPARC_INS_FQTOI = 159,
SPARC_INS_FQTOS = 160,
SPARC_INS_FQTOX = 161,
SPARC_INS_FSLAS16 = 162,
SPARC_INS_FSLAS32 = 163,
SPARC_INS_FSLL16 = 164,
SPARC_INS_FSLL32 = 165,
SPARC_INS_FSMULD = 166,
SPARC_INS_FSQRTD = 167,
SPARC_INS_FSQRTQ = 168,
SPARC_INS_FSQRTS = 169,
SPARC_INS_FSRA16 = 170,
SPARC_INS_FSRA32 = 171,
SPARC_INS_FSRC1 = 172,
SPARC_INS_FSRC1S = 173,
SPARC_INS_FSRC2 = 174,
SPARC_INS_FSRC2S = 175,
SPARC_INS_FSRL16 = 176,
SPARC_INS_FSRL32 = 177,
SPARC_INS_FSTOD = 178,
SPARC_INS_FSTOI = 179,
SPARC_INS_FSTOQ = 180,
SPARC_INS_FSTOX = 181,
SPARC_INS_FSUBD = 182,
SPARC_INS_FSUBQ = 183,
SPARC_INS_FSUBS = 184,
SPARC_INS_FXNOR = 185,
SPARC_INS_FXNORS = 186,
SPARC_INS_FXOR = 187,
SPARC_INS_FXORS = 188,
SPARC_INS_FXTOD = 189,
SPARC_INS_FXTOQ = 190,
SPARC_INS_FXTOS = 191,
SPARC_INS_FZERO = 192,
SPARC_INS_FZEROS = 193,
SPARC_INS_JMPL = 194,
SPARC_INS_LDD = 195,
SPARC_INS_LD = 196,
SPARC_INS_LDQ = 197,
SPARC_INS_LDSB = 198,
SPARC_INS_LDSH = 199,
SPARC_INS_LDSW = 200,
SPARC_INS_LDUB = 201,
SPARC_INS_LDUH = 202,
SPARC_INS_LDX = 203,
SPARC_INS_LZCNT = 204,
SPARC_INS_MEMBAR = 205,
SPARC_INS_MOVDTOX = 206,
SPARC_INS_MOV = 207,
SPARC_INS_MOVRGEZ = 208,
SPARC_INS_MOVRGZ = 209,
SPARC_INS_MOVRLEZ = 210,
SPARC_INS_MOVRLZ = 211,
SPARC_INS_MOVRNZ = 212,
SPARC_INS_MOVRZ = 213,
SPARC_INS_MOVSTOSW = 214,
SPARC_INS_MOVSTOUW = 215,
SPARC_INS_MULX = 216,
SPARC_INS_NOP = 217,
SPARC_INS_ORCC = 218,
SPARC_INS_ORNCC = 219,
SPARC_INS_ORN = 220,
SPARC_INS_OR = 221,
SPARC_INS_PDIST = 222,
SPARC_INS_PDISTN = 223,
SPARC_INS_POPC = 224,
SPARC_INS_RD = 225,
SPARC_INS_RESTORE = 226,
SPARC_INS_RETT = 227,
SPARC_INS_SAVE = 228,
SPARC_INS_SDIVCC = 229,
SPARC_INS_SDIVX = 230,
SPARC_INS_SDIV = 231,
SPARC_INS_SETHI = 232,
SPARC_INS_SHUTDOWN = 233,
SPARC_INS_SIAM = 234,
SPARC_INS_SLLX = 235,
SPARC_INS_SLL = 236,
SPARC_INS_SMULCC = 237,
SPARC_INS_SMUL = 238,
SPARC_INS_SRAX = 239,
SPARC_INS_SRA = 240,
SPARC_INS_SRLX = 241,
SPARC_INS_SRL = 242,
SPARC_INS_STBAR = 243,
SPARC_INS_STB = 244,
SPARC_INS_STD = 245,
SPARC_INS_ST = 246,
SPARC_INS_STH = 247,
SPARC_INS_STQ = 248,
SPARC_INS_STX = 249,
SPARC_INS_SUBCC = 250,
SPARC_INS_SUBX = 251,
SPARC_INS_SUBXCC = 252,
SPARC_INS_SUB = 253,
SPARC_INS_SWAP = 254,
SPARC_INS_TADDCCTV = 255,
SPARC_INS_TADDCC = 256,
SPARC_INS_T = 257,
SPARC_INS_TSUBCCTV = 258,
SPARC_INS_TSUBCC = 259,
SPARC_INS_UDIVCC = 260,
SPARC_INS_UDIVX = 261,
SPARC_INS_UDIV = 262,
SPARC_INS_UMULCC = 263,
SPARC_INS_UMULXHI = 264,
SPARC_INS_UMUL = 265,
SPARC_INS_UNIMP = 266,
SPARC_INS_FCMPED = 267,
SPARC_INS_FCMPEQ = 268,
SPARC_INS_FCMPES = 269,
SPARC_INS_WR = 270,
SPARC_INS_XMULX = 271,
SPARC_INS_XMULXHI = 272,
SPARC_INS_XNORCC = 273,
SPARC_INS_XNOR = 274,
SPARC_INS_XORCC = 275,
SPARC_INS_XOR = 276,
// alias instructions
SPARC_INS_RET = 277,
SPARC_INS_RETL = 278,
SPARC_INS_ENDING = 279 // <-- mark the end of the list of instructions
}
/// Group of SPARC instructions
enum sparc_insn_group
{
SPARC_GRP_INVALID = 0, ///< = CS_GRP_INVALID
// Generic groups
// all jump instructions (conditional+direct+indirect jumps)
SPARC_GRP_JUMP = 1, ///< = CS_GRP_JUMP
// Architecture-specific groups
SPARC_GRP_HARDQUAD = 128,
SPARC_GRP_V9 = 129,
SPARC_GRP_VIS = 130,
SPARC_GRP_VIS2 = 131,
SPARC_GRP_VIS3 = 132,
SPARC_GRP_32BIT = 133,
SPARC_GRP_64BIT = 134,
SPARC_GRP_ENDING = 135 // <-- mark the end of the list of groups
}
|
D
|
// Copyright Ferdinand Majerech 2010 - 2011.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
///Functions detecting contacts between physics bodies.
module physics.contactdetect;
@safe
import std.math;
import physics.physicsbody;
import physics.contact;
import spatial.volume;
import spatial.volumeaabbox;
import spatial.volumecircle;
import math.vector2;
import math.rectangle;
package:
/**
* Test for collision between two bodies.
*
* Params: body_a = First body.
* body_b = Second body.
* contact = Contact struct to write collision to, if any.
*
* Returns: True if a collision is detected, false otherwise.
*/
bool detect_contact(PhysicsBody body_a, PhysicsBody body_b, out Contact contact)
in{assert(body_a !is body_b, "Trying to detect contact of an object with itself.");}
body
{
//if a body has no collision volume, there can't be a collision
if(body_a.volume is null || body_b.volume is null){return false;}
contact.body_a = body_a;
contact.body_b = body_b;
//determine types of collision volumes and test for intersection
return intersection(body_a.position, body_b.position,
body_a.volume, body_b.volume, contact);
}
private:
/**
* Test for intersection between two collision volumes.
*
* Determines collision volume types and runs correct intersection tests.
*
* Params: position1 = Position of the first volume in world space.
* position2 = Position of the second volume in world space.
* volume1 = First volume.
* volume2 = Second volume.
* contact = Contact struct to write any intersection to.
*
* Returns: True if an intersection happened, false otherwise.
*/
bool intersection(in Vector2f position1, in Vector2f position2,
in Volume volume1, in Volume volume2,
ref Contact contact)
in
{
const class_a = volume1.classinfo;
const class_b = volume2.classinfo;
static aabbox = VolumeAABBox.classinfo;
static circle = VolumeCircle.classinfo;
assert(class_a is aabbox || class_a is circle, "Unsupported collision volume type");
assert(class_b is aabbox || class_b is circle, "Unsupported collision volume type");
assert(volume1 !is volume2, "Can't test intersection of a collision volume with itself");
}
body
{
const class_a = volume1.classinfo;
const class_b = volume2.classinfo;
static const aabbox = VolumeAABBox.classinfo;
static const circle = VolumeCircle.classinfo;
if(class_a is aabbox)
{
if(class_b is aabbox)
{
return aabbox_aabbox(position1, position2,
cast(VolumeAABBox)volume1,
cast(VolumeAABBox)volume2,
contact);
}
else if(class_b is circle)
{
return aabbox_circle(position1, position2,
cast(VolumeAABBox)volume1,
cast(VolumeCircle)volume2,
contact);
}
assert(false, "Unsupported collision volume type");
}
else if(class_a is circle)
{
if(class_b is aabbox)
{
//swapping volumes for test, then swapping them back in the contact
bool result = aabbox_circle(position1, position2,
cast(VolumeAABBox)volume2,
cast(VolumeCircle)volume1,
contact);
contact.swap_bodies();
return result;
}
else if(class_b is circle)
{
return circle_circle(position1, position2,
cast(VolumeCircle)volume1,
cast(VolumeCircle)volume2,
contact);
}
assert(false, "Unsupported collision volume type");
}
assert(false, "Unsupported collision volume type");
}
/**
* Test for intersection between two axis aligned bounding boxes.
*
* Params: box1_position = Top-left corner of the first bounding box in world space.
* box2_position = Top-left corner of the second bounding box in world space.
* box1 = First bounding box.
* box2 = Second bounding box.
* contact = Contact struct to write any intersection to.
*
* Returns: True if an intersection happened, false otherwise.
*/
bool aabbox_aabbox(in Vector2f box1_position, in Vector2f box2_position,
in VolumeAABBox box1, in VolumeAABBox box2,
ref Contact contact)
{
//combined half-widths/half-heights of the rectangles.
const Vector2f combined = (box1.rectangle.size + box2.rectangle.size) * 0.5f;
//distance between centers of the rectangles
const Vector2f distance = (box2_position + box2.rectangle.center) -
(box1_position + box1.rectangle.center);
//calculate absolute distance coords
//this is used to determine collision
const distance_abs = Vector2f(abs(distance.x), abs(distance.y));
//aabboxes are not intersecting if both of the following are false:
//their x distance is less than their combined halfwidths
//their y distance is less than their combined halfheights
if(!((distance_abs.x < combined.x) && (distance_abs.y < combined.y))) {return false;}
//magnitude of the normal vector is determined by the overlap of aabboxes
const normal_mag = combined - distance_abs;
contact.contact_normal.zero();
//only adjust the contact normal in the direction of the smallest overlap
if(normal_mag.x < normal_mag.y)
{
contact.penetration = abs(normal_mag.x);
contact.contact_normal.x = (distance.x > 0) ? 1.0f : -1.0f;
}
else
{
contact.penetration = abs(normal_mag.y);
contact.contact_normal.y = (distance.y > 0) ? 1.0f : -1.0f;
}
return true;
}
///Unittest for aabbox_aabbox().
unittest
{
//default initialized to zero vector
Vector2f zero;
auto box1 = new VolumeAABBox(zero, Vector2f(4.0f, 3.0f));
auto box2 = new VolumeAABBox(Vector2f(3.0f, 1.0f), Vector2f(3.0f, 1.0f));
auto box3 = new VolumeAABBox(Vector2f(4.1f, 1.0f), Vector2f(3.0f, 1.0f));
Contact contact;
assert(aabbox_aabbox(zero, zero, box1, box2, contact) == true);
assert(contact.contact_normal == Vector2f(1.0, 0.0));
assert(aabbox_aabbox(zero, zero, box1, box3, contact) == false);
assert(aabbox_aabbox(zero, Vector2f(1.0f, 0.0f), box1, box2, contact) == false);
assert(aabbox_aabbox(zero, Vector2f(-1.0f, 0.0f), box1, box3, contact) == true);
}
/**
* Test for intersection between two circles.
*
* Params: circle1_position = Center of the first circle in world space.
* circle2_position = Center of the second circle in world space.
* circle1 = First circle.
* circle2 = Second circle.
* contact = Contact struct to write any intersection to.
*
* Returns: True if an intersection happened, false otherwise.
*/
bool circle_circle(in Vector2f circle1_position, in Vector2f circle2_position,
in VolumeCircle circle1, in VolumeCircle circle2,
ref Contact contact)
{
//difference of circle positions in world space
Vector2f difference = (circle2.offset + circle2_position) -
(circle1.offset + circle1_position);
const float radius_total = circle1.radius + circle2.radius;
//will be positive if the objects are interpenetrating
const float penetration_sq = radius_total * radius_total - difference.length_squared;
if(penetration_sq < 0.0){return false;}
contact.penetration = sqrt(penetration_sq);
//degenerate case when the circles are at the same position
if(difference == Vector2f(0.0f, 0.0f)){difference.x = 1.0;}
difference.normalize_safe();
contact.contact_normal = difference;
return true;
}
///Unittest for circle_circle().
unittest
{
//default initialized to zero vector
Vector2f zero;
auto circle1 = new VolumeCircle(zero, 4.0f);
auto circle2 = new VolumeCircle(Vector2f(0.0f, 6.7f), 3.0f);
auto circle3 = new VolumeCircle(Vector2f(0.1f, 7.0f), 3.0f);
Contact contact;
assert(circle_circle(zero, zero, circle1, circle2, contact) == true);
assert(contact.contact_normal == Vector2f(0.0, 1.0));
assert(circle_circle(zero, zero, circle1, circle3, contact) == false);
assert(circle_circle(zero, Vector2f(0.0f, 1.0f), circle1, circle2, contact) == false);
assert(circle_circle(zero, Vector2f(0.0f, -1.0f), circle1, circle3, contact) == true);
}
/**
* Test for intersection between an axis aligned bounding box and a circle.
*
* Params: box_position = Top-left corner of the bounding box in world space.
* circle_position = Center of the circle in world space.
* box = Bounding box.
* circle = Circle.
* contact = Contact struct to write any intersection to.
*
* Returns: True if an intersection happened, false otherwise.
*/
bool aabbox_circle(in Vector2f box_position, in Vector2f circle_position,
in VolumeAABBox box, in VolumeCircle circle,
ref Contact contact)
{
//convert to box space
const Vector2f circle_center = circle.offset + circle_position - box_position;
//closest point to the circle on the box
const Vector2f closest = box.rectangle.clamp(circle_center);
//distance from the center of the circle to the box
Vector2f difference = circle_center - closest;
//will be positive if the objects are interpenetrating
const float penetration_sq = circle.radius * circle.radius - difference.length_squared;
if(penetration_sq < 0.0){return false;}
//degenerate case when the circle is exactly on the border of the box
if(difference == Vector2f(0.0f, 0.0f)){difference.x = 1.0;}
contact.penetration = sqrt(penetration_sq);
difference.normalize_safe();
contact.contact_normal = difference;
return true;
}
///Unittest for aabbox_circle().
unittest
{
//default-initialized to zero vector
Vector2f zero;
auto circle1 = new VolumeCircle(zero, 4.0f);
auto circle2 = new VolumeCircle(Vector2f(0.0f, 6.5f), 3.0f);
auto box1 = new VolumeAABBox(zero, Vector2f(4.0f, 3.0f));
auto box2 = new VolumeAABBox(Vector2f(-2.0f, -6.9f), Vector2f(4.0f, 3.0f));
Contact contact;
assert(aabbox_circle(zero, zero, box2, circle1, contact) == true);
assert(contact.contact_normal == Vector2f(0.0, 1.0));
assert(aabbox_circle(zero, zero, box1, circle2, contact) == false);
assert(aabbox_circle(zero, Vector2f(0.0f, 1.0f), box2, circle1, contact) == false);
assert(aabbox_circle(zero, Vector2f(0.0f, -1.0f), box1, circle2, contact) == true);
}
|
D
|
/Users/sapientisat/Projects/Supplements/Supplements/XcodeBuild/Intermediates.noindex/Pods.build/Debug-iphonesimulator/SnapKit.build/Objects-normal/x86_64/ConstraintDirectionalInsetTarget.o : /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuideDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutSupportDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintViewDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuide.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerExtendable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerRelatable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerEditable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerFinalizable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerPriortizable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintConfig.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Debugging.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintItem.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/LayoutConstraintItem.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintRelation.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDescription.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMaker.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Typealiases.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintAttributes.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuide+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/UILayoutSupport+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintView+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDirectionalInsets.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintInsets.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintRelatableTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMultiplierTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintOffsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDirectionalInsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintInsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintConstantTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintPriorityTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Constraint.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/LayoutConstraint.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutSupport.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintView.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintPriority.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreImage.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Combine.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/QuartzCore.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Metal.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Swift.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/UIKit.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Users/sapientisat/Projects/Supplements/Supplements/Pods/Target\ Support\ Files/SnapKit/SnapKit-umbrella.h /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/mach-o/dyld.modulemap /Users/sapientisat/Projects/Supplements/Supplements/XcodeBuild/Intermediates.noindex/Pods.build/Debug-iphonesimulator/SnapKit.build/unextended-module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/mach-o/compact_unwind_encoding.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/UserNotifications.framework/Headers/UserNotifications.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/sapientisat/Projects/Supplements/Supplements/XcodeBuild/Intermediates.noindex/Pods.build/Debug-iphonesimulator/SnapKit.build/Objects-normal/x86_64/ConstraintDirectionalInsetTarget~partial.swiftmodule : /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuideDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutSupportDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintViewDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuide.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerExtendable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerRelatable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerEditable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerFinalizable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerPriortizable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintConfig.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Debugging.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintItem.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/LayoutConstraintItem.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintRelation.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDescription.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMaker.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Typealiases.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintAttributes.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuide+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/UILayoutSupport+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintView+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDirectionalInsets.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintInsets.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintRelatableTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMultiplierTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintOffsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDirectionalInsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintInsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintConstantTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintPriorityTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Constraint.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/LayoutConstraint.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutSupport.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintView.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintPriority.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreImage.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Combine.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/QuartzCore.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Metal.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Swift.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/UIKit.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Users/sapientisat/Projects/Supplements/Supplements/Pods/Target\ Support\ Files/SnapKit/SnapKit-umbrella.h /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/mach-o/dyld.modulemap /Users/sapientisat/Projects/Supplements/Supplements/XcodeBuild/Intermediates.noindex/Pods.build/Debug-iphonesimulator/SnapKit.build/unextended-module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/mach-o/compact_unwind_encoding.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/UserNotifications.framework/Headers/UserNotifications.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/sapientisat/Projects/Supplements/Supplements/XcodeBuild/Intermediates.noindex/Pods.build/Debug-iphonesimulator/SnapKit.build/Objects-normal/x86_64/ConstraintDirectionalInsetTarget~partial.swiftdoc : /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuideDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutSupportDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintViewDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuide.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerExtendable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerRelatable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerEditable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerFinalizable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerPriortizable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintConfig.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Debugging.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintItem.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/LayoutConstraintItem.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintRelation.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDescription.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMaker.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Typealiases.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintAttributes.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuide+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/UILayoutSupport+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintView+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDirectionalInsets.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintInsets.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintRelatableTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMultiplierTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintOffsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDirectionalInsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintInsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintConstantTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintPriorityTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Constraint.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/LayoutConstraint.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutSupport.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintView.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintPriority.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreImage.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Combine.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/QuartzCore.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Metal.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Swift.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/UIKit.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Users/sapientisat/Projects/Supplements/Supplements/Pods/Target\ Support\ Files/SnapKit/SnapKit-umbrella.h /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/mach-o/dyld.modulemap /Users/sapientisat/Projects/Supplements/Supplements/XcodeBuild/Intermediates.noindex/Pods.build/Debug-iphonesimulator/SnapKit.build/unextended-module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/mach-o/compact_unwind_encoding.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/UserNotifications.framework/Headers/UserNotifications.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/sapientisat/Projects/Supplements/Supplements/XcodeBuild/Intermediates.noindex/Pods.build/Debug-iphonesimulator/SnapKit.build/Objects-normal/x86_64/ConstraintDirectionalInsetTarget~partial.swiftsourceinfo : /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuideDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutSupportDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintViewDSL.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuide.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerExtendable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerRelatable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerEditable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerFinalizable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMakerPriortizable.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintConfig.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Debugging.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintItem.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/LayoutConstraintItem.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintRelation.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDescription.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMaker.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Typealiases.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintAttributes.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutGuide+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/UILayoutSupport+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintView+Extensions.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDirectionalInsets.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintInsets.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintRelatableTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintMultiplierTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintOffsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintDirectionalInsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintInsetTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintConstantTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintPriorityTarget.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/Constraint.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/LayoutConstraint.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintLayoutSupport.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintView.swift /Users/sapientisat/Projects/Supplements/Supplements/Pods/SnapKit/Source/ConstraintPriority.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreImage.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Combine.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/QuartzCore.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Metal.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/Swift.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/UIKit.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-ios-simulator.swiftmodule /Users/sapientisat/Projects/Supplements/Supplements/Pods/Target\ Support\ Files/SnapKit/SnapKit-umbrella.h /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/mach-o/dyld.modulemap /Users/sapientisat/Projects/Supplements/Supplements/XcodeBuild/Intermediates.noindex/Pods.build/Debug-iphonesimulator/SnapKit.build/unextended-module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/mach-o/compact_unwind_encoding.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/UserNotifications.framework/Headers/UserNotifications.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.4.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
|
D
|
module interpretador;
import std.conv : to;
struct Instrucción {
Código código;
uint rf1;
uint rf2;
short inm;
@disable this ();
import memorias : Bloque, Tipo, palabra, bytesPorPalabra;
@safe this (palabra palabraInstrucción) {
import std.conv : to;
this.código = ((palabraInstrucción >> 26) & 0b111111).to!Código;
this.rf1 = ((palabraInstrucción >> 21) & 0b11111 );
this.rf2 = ((palabraInstrucción >> 16) & 0b11111 );
this.inm = cast (short) palabraInstrucción;
assert (this.rf1 < 32 && this.rf2 < 32);
}
}
enum Código : byte {
DADDI = 8 ,
DADD = 32,
DSUB = 34,
DMUL = 12,
DDIV = 14,
BEQZ = 4 ,
BNEZ = 5 ,
JAL = 3 ,
JR = 2 ,
LL = 50,
SC = 51,
LW = 35,
SW = 43,
FIN = 63
}
import nucleo : Núcleo;
import tui : interfazDeUsuario;
import memorias : memoriaPrincipal, bytesPorPalabra, cachéL1Datos;
static void interpretar (Núcleo núcleo, Instrucción instrucción) {
interfazDeUsuario.mostrarInstrucción (`Ejecutando `, instrucción);
with (instrucción) final switch (código) {
case Código.DADDI:
// Rx <-- (Ry) + n
auto Ry = núcleo.registros [rf1];
auto n = instrucción.inm;
núcleo.registros [rf2] = Ry + n;
break;
case Código.DADD:
// Rx <-- (Ry) + (Rz)
auto Ry = núcleo.registros [rf1];
auto Rz = núcleo.registros [rf2];
núcleo.registros [inm] = Ry + Rz;
break;
case Código.DSUB:
// Rx <-- (Ry) - (Rz)
auto Ry = núcleo.registros [rf1];
auto Rz = núcleo.registros [rf2];
núcleo.registros [inm] = Ry - Rz;
break;
case Código.DMUL:
// Rx <-- (Ry) * (Rz)
auto Ry = núcleo.registros [rf1];
auto Rz = núcleo.registros [rf2];
núcleo.registros [inm] = Ry * Rz;
break;
case Código.DDIV:
// Rx <-- (Ry) / (Rz)
auto Ry = núcleo.registros [rf1];
auto Rz = núcleo.registros [rf2];
if (Rz == 0) {
throw new ExcepciónDeFinDePrograma ();
}
núcleo.registros [inm] = Ry / Rz;
break;
case Código.BEQZ:
// Rx == 0 ? Salta a PC + Etiq + 1 : No hace nada
auto Rx = núcleo.registros [rf1];
assert (rf2 == 0, `rf2 debe ser 0`);
if (Rx == 0) {
// El 1 se suma automáticamente
núcleo.registros.contadorDePrograma += (inm * bytesPorPalabra);
}
break;
case Código.BNEZ:
// Rx != 0 ? Salta a PC + Etiq + 1 : No hace nada
auto Rx = núcleo.registros [rf1];
assert (rf2 == 0, `rf2 debe ser 0`);
if (Rx != 0) {
núcleo.registros.contadorDePrograma += (inm * bytesPorPalabra);
}
break;
case Código.JAL:
// R31 <-- PC, PC += n
assert (rf1 == 0 && rf2 == 0, `rf1 y rf2 deberían ser 0`);
assert (inm % bytesPorPalabra == 0, `Se esperaba un inmediato múltiplo de 4.`);
núcleo.registros [31] = núcleo.registros.contadorDePrograma;
núcleo.registros.contadorDePrograma += inm;
break;
case Código.JR:
// PC <-- (Rx)
assert (rf2 == 0 && inm == 0, `rf2 e inm deberían ser 0`);
auto Rx = núcleo.registros [rf1];
núcleo.registros.contadorDePrograma = Rx;
break;
case Código.LW:
// Rx <-- Memoria (n + (Ry))
int Ry = núcleo.registros [rf1];
int posBase = Ry + inm;
assert ((posBase % bytesPorPalabra) == 0
/**/ , `LW no alineado: ` ~ posBase.to!string);
uint posición = (posBase / bytesPorPalabra).to!int;
assert (posición >= 0 && posición < 256, `Pos fuera de memoria.`);
núcleo.registros [rf2] = cachéL1Datos.load (posición);
break;
case Código.SW:
// Memoria (n + (Ry)) <-- Rx
int Rx = núcleo.registros [rf2];
int Ry = núcleo.registros [rf1];
int posBase = Ry + inm;
assert ((posBase % bytesPorPalabra) == 0, `SW no alineado: ` ~ posBase.to!string);
uint posición = (posBase / bytesPorPalabra).to!int;
assert (posición >= 0 && posición < 256);
cachéL1Datos.store(Rx, posición);
break;
case Código.FIN:
// Stop stop stop stop.
throw new ExcepciónDeFinDePrograma ();
case Código.LL:
// Rx <-- Memoria (n + (Ry))
int Ry = núcleo.registros [rf1];
int posBase = Ry + inm;
assert ((posBase % bytesPorPalabra) == 0
/**/ , `LL no alineado: ` ~ posBase.to!string);
uint posición = (posBase / bytesPorPalabra).to!int;
assert (posición >= 0 && posición < 256, `Pos fuera de memoria.`);
núcleo.registros [rf2] = cachéL1Datos.load (posición, true);
break;
case Código.SC:
// Memoria (n + (Ry)) <-- Rx
int Rx = núcleo.registros [rf2];
int Ry = núcleo.registros [rf1];
int posBase = Ry + inm;
assert ((posBase % bytesPorPalabra) == 0, `SC no alineado: ` ~ posBase.to!string);
uint posición = (posBase / bytesPorPalabra).to!int;
assert (posición >= 0 && posición < 256);
cachéL1Datos.store (Rx, posición,
() {
núcleo.registros [rf2] = 0;
}, true);
break;
}
}
class ExcepciónDeFinDePrograma : Exception {
this () {
super (``);
}
}
|
D
|
/**
* Authors: Frank Benoit <keinfarbton@googlemail.com>
*/
module java.lang.System;
import java.lang.util;
import java.lang.exceptions;
import java.io.PrintStream;
version(Tango){
static import tango.sys.Environment;
static import tango.core.Exception;
static import tango.io.model.IFile;
static import tango.time.Clock;
static import tango.stdc.stdlib;
} else { // Phobos
static import std.c.stdlib;
static import std.datetime;
static import std.path;
}
template SimpleType(T) {
debug{
static void validCheck(uint SrcLen, uint DestLen, uint copyLen){
if(SrcLen < copyLen || DestLen < copyLen|| SrcLen < 0 || DestLen < 0){
//Util.trace("Error : SimpleType.arraycopy(), out of bounds.");
assert(0);
}
}
}
static void remove(ref T[] items, int index) {
if(items.length == 0)
return;
if(index < 0 || index >= items.length){
throw new ArrayIndexOutOfBoundsException(__FILE__, __LINE__);
}
T element = items[index];
int length = items.length;
if(length == 1){
items.length = 0;
return;// element;
}
if(index == 0)
items = items[1 .. $];
else if(index == length - 1)
items = items[0 .. index];
else
items = items[0 .. index] ~ items[index + 1 .. $];
}
static void insert(ref T[] items, T item, int index = -1) {
if(index == -1)
index = items.length;
if(index < 0 || index > items.length ){
throw new ArrayIndexOutOfBoundsException(__FILE__, __LINE__);
}
if(index == items.length){
items ~= item;
}else if(index == 0){
T[] newVect;
newVect ~= item;
items = newVect ~ items;
}else if(index < items.length ){
T[] arr1 = items[0 .. index];
T[] arr2 = items[index .. $];
// Important : if you write like the following commented,
// you get wrong data
// code: T[] arr1 = items[0..index];
// T[] arr2 = items[index..$];
// items = arr1 ~ item; // error, !!!
// items ~= arr2; // item replace the arrr2[0] here
items = arr1 ~ item ~ arr2;
}
}
static void arraycopy(in T[] src, uint srcPos, T[] dest, uint destPos, uint len)
{
if(len == 0) return;
assert(src);
assert(dest);
debug{validCheck(src.length - srcPos, dest.length - destPos, len);}
// overlapping?
if((src.ptr <= dest.ptr && src.ptr + len > dest.ptr)
||(src.ptr >= dest.ptr && src.ptr < dest.ptr + len)){
if( destPos < srcPos ){
for(int i=0; i<len; ++i){
dest[destPos+i] = cast(T)src[srcPos+i];
}
}
else{
for(int i=len-1; i>=0; --i){
dest[destPos+i] = cast(T)src[srcPos+i];
}
}
}else{
dest[destPos..(len+destPos)] = cast(T[])src[srcPos..(len+srcPos)];
}
}
}
class System {
static void arraycopy(T)(in T[] src, uint srcPos, T[] dest, uint destPos, uint len) {
if(len == 0) return;
assert(src);
assert(dest);
debug{SimpleType!(T).validCheck(src.length - srcPos, dest.length - destPos, len);}
// overlapping?
if((src.ptr <= dest.ptr && src.ptr + len > dest.ptr)
||(src.ptr >= dest.ptr && src.ptr < dest.ptr + len)){
if( destPos < srcPos ){
for(int i=0; i<len; ++i){
dest[destPos+i] = cast(T)src[srcPos+i];
}
}
else{
for(int i=len-1; i>=0; --i){
dest[destPos+i] = cast(T)src[srcPos+i];
}
}
}else{
dest[destPos..(len+destPos)] = cast(T[])src[srcPos..(len+srcPos)];
}
}
static long currentTimeMillis(){
version(Tango) return tango.time.Clock.Clock.now().ticks() / 10000;
else return std.datetime.Clock.currStdTime();
}
static void exit( int code ){
version(Tango) tango.stdc.stdlib.exit(code);
else std.c.stdlib.exit(code);
}
public static int identityHashCode(Object x){
if( x is null ){
return 0;
}
return (*cast(Object *)&x).toHash();
}
public static String getProperty( String key, String defval ){
String res = getProperty(key);
if( res ){
return res;
}
return defval;
}
public static String getProperty( String key ){
/* Get values for local org.eclipse.swt specific keys */
String* p;
if (key[0..3] == "org.eclipse.swt") {
return ((p = key in localProperties) != null) ? *p : null;
/* else get values for global system keys (environment) */
} else {
switch( key ){
case "os.name": return "linux";
case "user.name": return "";
case "user.home": return "";
case "user.dir" : return "";
case "file.separator" :
version(Tango) return tango.io.model.IFile.FileConst.PathSeparatorString ;
else return std.path.dirSeparator;
default: return null;
}
}
}
public static void setProperty ( String key, String value ) {
/* set property for local org.eclipse.swt keys */
if (key[0..3] == "org.eclipse.swt") {
if (key !is null && value !is null)
localProperties[ key ] = value;
/* else set properties for global system keys (environment) */
} else {
}
}
private static PrintStream err__;
public static PrintStream err(){
if( err__ is null ){
err__ = new PrintStream(null);
}
return err__;
}
private static PrintStream out__;
public static PrintStream out_(){
if( out__ is null ){
out__ = new PrintStream(null);
}
return out__;
}
private static String[String] localProperties;
}
|
D
|
module app.form.CommentForm;
import hunt.framework;
class CommentForm : Form
{
mixin MakeForm;
@Min(0)
int postId;
@Length(1, 10000)
string content;
}
|
D
|
/*---------------------------------------------------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.4.0 |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
Build : 2.4.0-f0842aea0e77
Exec : pisoFoam
Date : Oct 03 2015
Time : 00:17:27
Host : "ubuntu"
PID : 41436
Case : /home/brennanharris/OpenFOAM/brennanharris-2.4.0/run/self/40000_curved
nProcs : 1
sigFpe : Enabling floating point exception trapping (FOAM_SIGFPE).
fileModificationChecking : Monitoring run-time modified files using timeStampMaster
allowSystemOperations : Allowing user-supplied system call operations
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Create time
Create mesh for time = 0
Reading field p
Reading field U
Reading/calculating face flux field phi
Selecting incompressible transport model Newtonian
Selecting turbulence model type RASModel
Selecting RAS turbulence model kEpsilon
kEpsilonCoeffs
{
Cmu 0.09;
C1 1.44;
C2 1.92;
sigmaEps 1.3;
}
Starting time loop
Time = 0.0025
Courant Number mean: 0.000499327 max: 0.0735127
smoothSolver: Solving for Ux, Initial residual = 1, Final residual = 9.35102e-06, No Iterations 24
smoothSolver: Solving for Uy, Initial residual = 1, Final residual = 9.11724e-06, No Iterations 24
GAMG: Solving for p, Initial residual = 1, Final residual = 0.0739293, No Iterations 16
time step continuity errors : sum local = 7.38299e-05, global = -3.91367e-06, cumulative = -3.91367e-06
GAMG: Solving for p, Initial residual = 0.139, Final residual = 7.15054e-07, No Iterations 46
time step continuity errors : sum local = 3.60283e-08, global = 2.5531e-09, cumulative = -3.91112e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0679772, Final residual = 5.2749e-06, No Iterations 10
smoothSolver: Solving for k, Initial residual = 1, Final residual = 8.29723e-06, No Iterations 19
ExecutionTime = 0.11 s ClockTime = 0 s
Time = 0.005
Courant Number mean: 0.0778837 max: 0.420417
smoothSolver: Solving for Ux, Initial residual = 0.872467, Final residual = 9.45373e-06, No Iterations 14
smoothSolver: Solving for Uy, Initial residual = 0.542717, Final residual = 7.18892e-06, No Iterations 15
GAMG: Solving for p, Initial residual = 0.166513, Final residual = 0.0132627, No Iterations 8
time step continuity errors : sum local = 0.00102904, global = 3.64791e-05, cumulative = 3.2568e-05
GAMG: Solving for p, Initial residual = 0.139106, Final residual = 6.94232e-07, No Iterations 44
time step continuity errors : sum local = 4.04086e-08, global = -2.51922e-09, cumulative = 3.25655e-05
smoothSolver: Solving for epsilon, Initial residual = 0.00911234, Final residual = 8.69127e-06, No Iterations 7
smoothSolver: Solving for k, Initial residual = 0.254404, Final residual = 8.54258e-06, No Iterations 15
ExecutionTime = 0.15 s ClockTime = 0 s
Time = 0.0075
Courant Number mean: 0.0808504 max: 0.482364
smoothSolver: Solving for Ux, Initial residual = 0.228377, Final residual = 5.79631e-06, No Iterations 16
smoothSolver: Solving for Uy, Initial residual = 0.980037, Final residual = 8.66179e-06, No Iterations 17
GAMG: Solving for p, Initial residual = 0.506219, Final residual = 0.0436525, No Iterations 7
time step continuity errors : sum local = 0.000754842, global = -3.47577e-05, cumulative = -2.19219e-06
GAMG: Solving for p, Initial residual = 0.32137, Final residual = 8.99711e-07, No Iterations 45
time step continuity errors : sum local = 1.25811e-08, global = 6.39188e-10, cumulative = -2.19155e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00573081, Final residual = 8.31873e-06, No Iterations 8
smoothSolver: Solving for k, Initial residual = 0.0916486, Final residual = 8.95913e-06, No Iterations 15
ExecutionTime = 0.19 s ClockTime = 0 s
Time = 0.01
Courant Number mean: 0.0790311 max: 0.395761
smoothSolver: Solving for Ux, Initial residual = 0.124795, Final residual = 9.82017e-06, No Iterations 15
smoothSolver: Solving for Uy, Initial residual = 0.305975, Final residual = 8.18724e-06, No Iterations 17
GAMG: Solving for p, Initial residual = 0.343982, Final residual = 0.0219552, No Iterations 9
time step continuity errors : sum local = 0.000221249, global = 1.06034e-05, cumulative = 8.41188e-06
GAMG: Solving for p, Initial residual = 0.193238, Final residual = 9.73449e-07, No Iterations 49
time step continuity errors : sum local = 1.0058e-08, global = -6.03498e-10, cumulative = 8.41128e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00673053, Final residual = 8.86325e-06, No Iterations 9
smoothSolver: Solving for k, Initial residual = 0.0724231, Final residual = 8.07215e-06, No Iterations 16
ExecutionTime = 0.24 s ClockTime = 0 s
Time = 0.0125
Courant Number mean: 0.0796252 max: 0.431334
smoothSolver: Solving for Ux, Initial residual = 0.0620706, Final residual = 7.6301e-06, No Iterations 15
smoothSolver: Solving for Uy, Initial residual = 0.198772, Final residual = 9.4269e-06, No Iterations 17
GAMG: Solving for p, Initial residual = 0.423925, Final residual = 0.0251437, No Iterations 9
time step continuity errors : sum local = 0.000117714, global = -6.72375e-06, cumulative = 1.68752e-06
GAMG: Solving for p, Initial residual = 0.186569, Final residual = 8.02969e-07, No Iterations 51
time step continuity errors : sum local = 4.4789e-09, global = 2.76553e-10, cumulative = 1.6878e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00452792, Final residual = 7.86816e-06, No Iterations 8
smoothSolver: Solving for k, Initial residual = 0.0442898, Final residual = 7.07746e-06, No Iterations 14
ExecutionTime = 0.29 s ClockTime = 0 s
Time = 0.015
Courant Number mean: 0.0792032 max: 0.438338
smoothSolver: Solving for Ux, Initial residual = 0.0297015, Final residual = 8.69426e-06, No Iterations 14
smoothSolver: Solving for Uy, Initial residual = 0.0893683, Final residual = 9.61094e-06, No Iterations 16
GAMG: Solving for p, Initial residual = 0.378582, Final residual = 0.0374512, No Iterations 7
time step continuity errors : sum local = 0.000119042, global = 8.76243e-06, cumulative = 1.04502e-05
GAMG: Solving for p, Initial residual = 0.198608, Final residual = 8.56989e-07, No Iterations 41
time step continuity errors : sum local = 2.69695e-09, global = -1.33522e-10, cumulative = 1.04501e-05
smoothSolver: Solving for epsilon, Initial residual = 0.00473514, Final residual = 7.45592e-06, No Iterations 8
smoothSolver: Solving for k, Initial residual = 0.0348485, Final residual = 9.66158e-06, No Iterations 13
ExecutionTime = 0.33 s ClockTime = 0 s
Time = 0.0175
Courant Number mean: 0.0794866 max: 0.455288
smoothSolver: Solving for Ux, Initial residual = 0.023405, Final residual = 6.52052e-06, No Iterations 14
smoothSolver: Solving for Uy, Initial residual = 0.0630027, Final residual = 6.97332e-06, No Iterations 16
GAMG: Solving for p, Initial residual = 0.394906, Final residual = 0.0393382, No Iterations 7
time step continuity errors : sum local = 8.13725e-05, global = -6.22029e-06, cumulative = 4.22981e-06
GAMG: Solving for p, Initial residual = 0.174821, Final residual = 8.76509e-07, No Iterations 41
time step continuity errors : sum local = 2.18564e-09, global = 1.11861e-10, cumulative = 4.22992e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0036573, Final residual = 6.98556e-06, No Iterations 7
smoothSolver: Solving for k, Initial residual = 0.0288105, Final residual = 9.58214e-06, No Iterations 12
ExecutionTime = 0.37 s ClockTime = 0 s
Time = 0.02
Courant Number mean: 0.0792757 max: 0.473948
smoothSolver: Solving for Ux, Initial residual = 0.0144397, Final residual = 8.19142e-06, No Iterations 13
smoothSolver: Solving for Uy, Initial residual = 0.037682, Final residual = 8.29296e-06, No Iterations 15
GAMG: Solving for p, Initial residual = 0.324682, Final residual = 0.0198522, No Iterations 9
time step continuity errors : sum local = 3.20882e-05, global = 2.34387e-06, cumulative = 6.57379e-06
GAMG: Solving for p, Initial residual = 0.166948, Final residual = 7.18796e-07, No Iterations 51
time step continuity errors : sum local = 1.22506e-09, global = -8.74659e-11, cumulative = 6.5737e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00368716, Final residual = 6.48455e-06, No Iterations 7
smoothSolver: Solving for k, Initial residual = 0.0246641, Final residual = 8.08758e-06, No Iterations 12
ExecutionTime = 0.41 s ClockTime = 0 s
Time = 0.0225
Courant Number mean: 0.0795326 max: 0.491956
smoothSolver: Solving for Ux, Initial residual = 0.00941746, Final residual = 9.63901e-06, No Iterations 12
smoothSolver: Solving for Uy, Initial residual = 0.0255399, Final residual = 9.71897e-06, No Iterations 14
GAMG: Solving for p, Initial residual = 0.38866, Final residual = 0.0376223, No Iterations 7
time step continuity errors : sum local = 3.30343e-05, global = -3.05117e-06, cumulative = 3.52253e-06
GAMG: Solving for p, Initial residual = 0.149736, Final residual = 7.38677e-07, No Iterations 41
time step continuity errors : sum local = 9.05557e-10, global = 5.14746e-11, cumulative = 3.52258e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00324682, Final residual = 8.84126e-06, No Iterations 6
smoothSolver: Solving for k, Initial residual = 0.0227183, Final residual = 7.14228e-06, No Iterations 12
ExecutionTime = 0.45 s ClockTime = 0 s
Time = 0.025
Courant Number mean: 0.0795088 max: 0.508633
smoothSolver: Solving for Ux, Initial residual = 0.00708867, Final residual = 6.9772e-06, No Iterations 12
smoothSolver: Solving for Uy, Initial residual = 0.0174163, Final residual = 6.80879e-06, No Iterations 14
GAMG: Solving for p, Initial residual = 0.262518, Final residual = 0.0159305, No Iterations 9
time step continuity errors : sum local = 1.41092e-05, global = 1.10447e-06, cumulative = 4.62705e-06
GAMG: Solving for p, Initial residual = 0.157969, Final residual = 8.65416e-07, No Iterations 49
time step continuity errors : sum local = 6.98915e-10, global = -5.23709e-11, cumulative = 4.627e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00316308, Final residual = 8.08284e-06, No Iterations 6
smoothSolver: Solving for k, Initial residual = 0.0206546, Final residual = 6.85499e-06, No Iterations 12
ExecutionTime = 0.5 s ClockTime = 1 s
Time = 0.0275
Courant Number mean: 0.0797604 max: 0.523847
smoothSolver: Solving for Ux, Initial residual = 0.00504477, Final residual = 8.63467e-06, No Iterations 11
smoothSolver: Solving for Uy, Initial residual = 0.012664, Final residual = 8.16321e-06, No Iterations 13
GAMG: Solving for p, Initial residual = 0.378366, Final residual = 0.0355309, No Iterations 7
time step continuity errors : sum local = 1.44619e-05, global = -1.4314e-06, cumulative = 3.1956e-06
GAMG: Solving for p, Initial residual = 0.116671, Final residual = 6.9027e-07, No Iterations 41
time step continuity errors : sum local = 4.83838e-10, global = 2.96443e-11, cumulative = 3.19563e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00297239, Final residual = 7.04643e-06, No Iterations 6
smoothSolver: Solving for k, Initial residual = 0.0193318, Final residual = 6.37518e-06, No Iterations 12
ExecutionTime = 0.54 s ClockTime = 1 s
Time = 0.03
Courant Number mean: 0.079816 max: 0.537625
smoothSolver: Solving for Ux, Initial residual = 0.0039143, Final residual = 9.38029e-06, No Iterations 10
smoothSolver: Solving for Uy, Initial residual = 0.00938941, Final residual = 8.97826e-06, No Iterations 12
GAMG: Solving for p, Initial residual = 0.19309, Final residual = 0.0188191, No Iterations 7
time step continuity errors : sum local = 1.03086e-05, global = 9.57279e-07, cumulative = 4.15291e-06
GAMG: Solving for p, Initial residual = 0.166031, Final residual = 7.11432e-07, No Iterations 43
time step continuity errors : sum local = 2.45071e-10, global = -1.57805e-11, cumulative = 4.15289e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00286376, Final residual = 6.5027e-06, No Iterations 6
smoothSolver: Solving for k, Initial residual = 0.0179833, Final residual = 6.35175e-06, No Iterations 12
ExecutionTime = 0.58 s ClockTime = 1 s
Time = 0.0325
Courant Number mean: 0.0800494 max: 0.549735
smoothSolver: Solving for Ux, Initial residual = 0.00337996, Final residual = 8.10664e-06, No Iterations 10
smoothSolver: Solving for Uy, Initial residual = 0.00751857, Final residual = 6.91381e-06, No Iterations 12
GAMG: Solving for p, Initial residual = 0.328205, Final residual = 0.0314599, No Iterations 7
time step continuity errors : sum local = 7.09102e-06, global = -6.61371e-07, cumulative = 3.49152e-06
GAMG: Solving for p, Initial residual = 0.0817536, Final residual = 9.48166e-07, No Iterations 39
time step continuity errors : sum local = 4.51966e-10, global = 3.05572e-11, cumulative = 3.49155e-06
smoothSolver: Solving for epsilon, Initial residual = 0.002726, Final residual = 6.14043e-06, No Iterations 6
smoothSolver: Solving for k, Initial residual = 0.016952, Final residual = 5.98917e-06, No Iterations 12
ExecutionTime = 0.62 s ClockTime = 1 s
Time = 0.035
Courant Number mean: 0.0801525 max: 0.5603
smoothSolver: Solving for Ux, Initial residual = 0.00253749, Final residual = 7.4132e-06, No Iterations 9
smoothSolver: Solving for Uy, Initial residual = 0.00597396, Final residual = 6.97188e-06, No Iterations 11
GAMG: Solving for p, Initial residual = 0.125849, Final residual = 0.012222, No Iterations 7
time step continuity errors : sum local = 4.80408e-06, global = 4.38603e-07, cumulative = 3.93016e-06
GAMG: Solving for p, Initial residual = 0.130845, Final residual = 8.66336e-07, No Iterations 41
time step continuity errors : sum local = 1.72769e-10, global = -1.11186e-11, cumulative = 3.93014e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00260779, Final residual = 5.79169e-06, No Iterations 6
smoothSolver: Solving for k, Initial residual = 0.0160252, Final residual = 5.88749e-06, No Iterations 12
ExecutionTime = 0.66 s ClockTime = 1 s
Time = 0.0375
Courant Number mean: 0.0803356 max: 0.569608
smoothSolver: Solving for Ux, Initial residual = 0.00237222, Final residual = 7.59731e-06, No Iterations 9
smoothSolver: Solving for Uy, Initial residual = 0.00514373, Final residual = 9.62566e-06, No Iterations 10
GAMG: Solving for p, Initial residual = 0.146537, Final residual = 0.0138327, No Iterations 7
time step continuity errors : sum local = 3.23698e-06, global = -2.95254e-07, cumulative = 3.63489e-06
GAMG: Solving for p, Initial residual = 0.0493718, Final residual = 9.25414e-07, No Iterations 37
time step continuity errors : sum local = 3.31535e-10, global = 2.25987e-11, cumulative = 3.63491e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0025038, Final residual = 5.56356e-06, No Iterations 6
smoothSolver: Solving for k, Initial residual = 0.0152232, Final residual = 9.52845e-06, No Iterations 11
ExecutionTime = 0.69 s ClockTime = 1 s
Time = 0.04
Courant Number mean: 0.0804507 max: 0.577523
smoothSolver: Solving for Ux, Initial residual = 0.00192002, Final residual = 9.19811e-06, No Iterations 7
smoothSolver: Solving for Uy, Initial residual = 0.00433683, Final residual = 8.39834e-06, No Iterations 9
GAMG: Solving for p, Initial residual = 0.0731637, Final residual = 0.0067734, No Iterations 7
time step continuity errors : sum local = 2.1792e-06, global = 1.90521e-07, cumulative = 3.82543e-06
GAMG: Solving for p, Initial residual = 0.0508749, Final residual = 7.62896e-07, No Iterations 37
time step continuity errors : sum local = 1.77891e-10, global = -1.08802e-11, cumulative = 3.82542e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0024233, Final residual = 5.34426e-06, No Iterations 6
smoothSolver: Solving for k, Initial residual = 0.0145263, Final residual = 9.20572e-06, No Iterations 11
ExecutionTime = 0.73 s ClockTime = 1 s
Time = 0.0425
Courant Number mean: 0.0806037 max: 0.584172
smoothSolver: Solving for Ux, Initial residual = 0.00189249, Final residual = 7.44265e-06, No Iterations 8
smoothSolver: Solving for Uy, Initial residual = 0.00408101, Final residual = 8.81584e-06, No Iterations 9
GAMG: Solving for p, Initial residual = 0.0667954, Final residual = 0.00582679, No Iterations 7
time step continuity errors : sum local = 1.45661e-06, global = -1.27867e-07, cumulative = 3.69756e-06
GAMG: Solving for p, Initial residual = 0.0259823, Final residual = 8.21223e-07, No Iterations 35
time step continuity errors : sum local = 2.49917e-10, global = 1.72103e-11, cumulative = 3.69757e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00236743, Final residual = 5.13207e-06, No Iterations 6
smoothSolver: Solving for k, Initial residual = 0.013916, Final residual = 8.74382e-06, No Iterations 11
ExecutionTime = 0.76 s ClockTime = 1 s
Time = 0.045
Courant Number mean: 0.0807324 max: 0.58967
smoothSolver: Solving for Ux, Initial residual = 0.00169375, Final residual = 6.14323e-06, No Iterations 7
smoothSolver: Solving for Uy, Initial residual = 0.00362749, Final residual = 6.25013e-06, No Iterations 8
GAMG: Solving for p, Initial residual = 0.0428354, Final residual = 0.00365564, No Iterations 7
time step continuity errors : sum local = 1.0523e-06, global = 8.30689e-08, cumulative = 3.78064e-06
GAMG: Solving for p, Initial residual = 0.0225534, Final residual = 7.15062e-07, No Iterations 33
time step continuity errors : sum local = 1.77819e-10, global = -9.28605e-12, cumulative = 3.78063e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00232255, Final residual = 4.9235e-06, No Iterations 6
smoothSolver: Solving for k, Initial residual = 0.0133812, Final residual = 8.37717e-06, No Iterations 11
ExecutionTime = 0.81 s ClockTime = 1 s
Time = 0.0475
Courant Number mean: 0.0808809 max: 0.594031
smoothSolver: Solving for Ux, Initial residual = 0.00167621, Final residual = 7.91004e-06, No Iterations 7
smoothSolver: Solving for Uy, Initial residual = 0.00366236, Final residual = 9.50656e-06, No Iterations 8
GAMG: Solving for p, Initial residual = 0.0334636, Final residual = 0.00224045, No Iterations 7
time step continuity errors : sum local = 5.74289e-07, global = -4.77875e-08, cumulative = 3.73285e-06
GAMG: Solving for p, Initial residual = 0.0125127, Final residual = 7.0861e-07, No Iterations 34
time step continuity errors : sum local = 1.97434e-10, global = 1.4156e-11, cumulative = 3.73286e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00228778, Final residual = 4.71579e-06, No Iterations 6
smoothSolver: Solving for k, Initial residual = 0.0128929, Final residual = 7.91428e-06, No Iterations 11
ExecutionTime = 0.85 s ClockTime = 1 s
Time = 0.05
Courant Number mean: 0.0810224 max: 0.597415
smoothSolver: Solving for Ux, Initial residual = 0.0015716, Final residual = 8.46316e-06, No Iterations 6
smoothSolver: Solving for Uy, Initial residual = 0.00339685, Final residual = 7.36362e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.023595, Final residual = 0.00163848, No Iterations 7
time step continuity errors : sum local = 4.43703e-07, global = 3.20522e-08, cumulative = 3.76491e-06
GAMG: Solving for p, Initial residual = 0.00984376, Final residual = 6.83028e-07, No Iterations 29
time step continuity errors : sum local = 1.73476e-10, global = -9.28263e-12, cumulative = 3.7649e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00224396, Final residual = 9.67277e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0125303, Final residual = 7.48876e-06, No Iterations 11
ExecutionTime = 0.88 s ClockTime = 1 s
Time = 0.0525
Courant Number mean: 0.0811764 max: 0.599967
smoothSolver: Solving for Ux, Initial residual = 0.00155408, Final residual = 5.69053e-06, No Iterations 7
smoothSolver: Solving for Uy, Initial residual = 0.00345909, Final residual = 6.96688e-06, No Iterations 8
GAMG: Solving for p, Initial residual = 0.0195747, Final residual = 0.00142649, No Iterations 5
time step continuity errors : sum local = 3.66891e-07, global = -4.82239e-08, cumulative = 3.71668e-06
GAMG: Solving for p, Initial residual = 0.0057556, Final residual = 7.88109e-07, No Iterations 29
time step continuity errors : sum local = 2.08123e-10, global = -9.38266e-12, cumulative = 3.71667e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00219779, Final residual = 9.263e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0122015, Final residual = 7.06186e-06, No Iterations 11
ExecutionTime = 0.92 s ClockTime = 1 s
Time = 0.055
Courant Number mean: 0.0813312 max: 0.60182
smoothSolver: Solving for Ux, Initial residual = 0.00148575, Final residual = 7.07708e-06, No Iterations 6
smoothSolver: Solving for Uy, Initial residual = 0.00330875, Final residual = 8.07128e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.0159767, Final residual = 0.00145758, No Iterations 5
time step continuity errors : sum local = 3.83746e-07, global = 3.49176e-08, cumulative = 3.75159e-06
GAMG: Solving for p, Initial residual = 0.00545802, Final residual = 7.63293e-07, No Iterations 32
time step continuity errors : sum local = 1.95221e-10, global = 1.32756e-11, cumulative = 3.7516e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00214511, Final residual = 8.86157e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0118884, Final residual = 6.62331e-06, No Iterations 11
ExecutionTime = 0.96 s ClockTime = 1 s
Time = 0.0575
Courant Number mean: 0.0814943 max: 0.60308
smoothSolver: Solving for Ux, Initial residual = 0.0014782, Final residual = 8.13859e-06, No Iterations 6
smoothSolver: Solving for Uy, Initial residual = 0.00331875, Final residual = 5.75309e-06, No Iterations 8
GAMG: Solving for p, Initial residual = 0.0148045, Final residual = 0.000796138, No Iterations 5
time step continuity errors : sum local = 2.03693e-07, global = -2.82416e-08, cumulative = 3.72336e-06
GAMG: Solving for p, Initial residual = 0.00360429, Final residual = 9.65729e-07, No Iterations 25
time step continuity errors : sum local = 2.5038e-10, global = -1.01477e-11, cumulative = 3.72335e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00210394, Final residual = 8.4418e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0115722, Final residual = 6.1681e-06, No Iterations 11
ExecutionTime = 1 s ClockTime = 1 s
Time = 0.06
Courant Number mean: 0.0816601 max: 0.603827
smoothSolver: Solving for Ux, Initial residual = 0.00142236, Final residual = 6.27461e-06, No Iterations 6
smoothSolver: Solving for Uy, Initial residual = 0.0032243, Final residual = 8.07847e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.0126368, Final residual = 0.000812986, No Iterations 5
time step continuity errors : sum local = 2.10414e-07, global = 1.63239e-08, cumulative = 3.73967e-06
GAMG: Solving for p, Initial residual = 0.00339244, Final residual = 9.37206e-07, No Iterations 27
time step continuity errors : sum local = 2.38653e-10, global = -1.75261e-11, cumulative = 3.73965e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0020704, Final residual = 8.07126e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0112543, Final residual = 9.60275e-06, No Iterations 10
ExecutionTime = 1.03 s ClockTime = 1 s
Time = 0.0625
Courant Number mean: 0.081823 max: 0.604155
smoothSolver: Solving for Ux, Initial residual = 0.00140971, Final residual = 6.82276e-06, No Iterations 6
smoothSolver: Solving for Uy, Initial residual = 0.0032182, Final residual = 8.88658e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.0120056, Final residual = 0.000952574, No Iterations 3
time step continuity errors : sum local = 2.42551e-07, global = -4.16385e-08, cumulative = 3.69802e-06
GAMG: Solving for p, Initial residual = 0.00243376, Final residual = 7.31996e-07, No Iterations 28
time step continuity errors : sum local = 1.86709e-10, global = -1.31561e-11, cumulative = 3.698e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0020449, Final residual = 7.7131e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0109481, Final residual = 9.00695e-06, No Iterations 10
ExecutionTime = 1.07 s ClockTime = 1 s
Time = 0.065
Courant Number mean: 0.0819797 max: 0.604134
smoothSolver: Solving for Ux, Initial residual = 0.00136827, Final residual = 5.69362e-06, No Iterations 6
smoothSolver: Solving for Uy, Initial residual = 0.00317829, Final residual = 7.5352e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.011544, Final residual = 0.000956751, No Iterations 3
time step continuity errors : sum local = 2.44504e-07, global = 2.61899e-08, cumulative = 3.72419e-06
GAMG: Solving for p, Initial residual = 0.00248432, Final residual = 8.51806e-07, No Iterations 28
time step continuity errors : sum local = 2.15927e-10, global = 1.54283e-11, cumulative = 3.72421e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00201437, Final residual = 7.36906e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.010679, Final residual = 8.44979e-06, No Iterations 10
ExecutionTime = 1.1 s ClockTime = 1 s
Time = 0.0675
Courant Number mean: 0.0821308 max: 0.603825
smoothSolver: Solving for Ux, Initial residual = 0.00135716, Final residual = 6.11106e-06, No Iterations 6
smoothSolver: Solving for Uy, Initial residual = 0.00318083, Final residual = 7.76854e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.0108937, Final residual = 0.000796742, No Iterations 3
time step continuity errors : sum local = 2.00904e-07, global = -2.74476e-08, cumulative = 3.69676e-06
GAMG: Solving for p, Initial residual = 0.00214462, Final residual = 9.54694e-07, No Iterations 26
time step continuity errors : sum local = 2.41104e-10, global = -1.52913e-11, cumulative = 3.69675e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00198229, Final residual = 7.03984e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0104772, Final residual = 7.94166e-06, No Iterations 10
ExecutionTime = 1.13 s ClockTime = 1 s
Time = 0.07
Courant Number mean: 0.0822755 max: 0.603284
smoothSolver: Solving for Ux, Initial residual = 0.00132089, Final residual = 5.12612e-06, No Iterations 6
smoothSolver: Solving for Uy, Initial residual = 0.00317876, Final residual = 6.80518e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.0104275, Final residual = 0.000942866, No Iterations 3
time step continuity errors : sum local = 2.38754e-07, global = 2.24425e-08, cumulative = 3.71919e-06
GAMG: Solving for p, Initial residual = 0.00230623, Final residual = 7.08869e-07, No Iterations 28
time step continuity errors : sum local = 1.78278e-10, global = 1.1956e-11, cumulative = 3.7192e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00194985, Final residual = 6.73238e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0102981, Final residual = 7.49071e-06, No Iterations 10
ExecutionTime = 1.16 s ClockTime = 1 s
Time = 0.0725
Courant Number mean: 0.0824142 max: 0.602563
smoothSolver: Solving for Ux, Initial residual = 0.00131318, Final residual = 5.47805e-06, No Iterations 6
smoothSolver: Solving for Uy, Initial residual = 0.00319136, Final residual = 6.85907e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.00926987, Final residual = 0.000756452, No Iterations 3
time step continuity errors : sum local = 1.89767e-07, global = -2.54228e-08, cumulative = 3.69378e-06
GAMG: Solving for p, Initial residual = 0.00184261, Final residual = 8.79831e-07, No Iterations 26
time step continuity errors : sum local = 2.21166e-10, global = -1.28459e-11, cumulative = 3.69376e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00191533, Final residual = 6.44388e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0101303, Final residual = 7.09714e-06, No Iterations 10
ExecutionTime = 1.19 s ClockTime = 1 s
Time = 0.075
Courant Number mean: 0.0825469 max: 0.60171
smoothSolver: Solving for Ux, Initial residual = 0.00128243, Final residual = 9.25026e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00319942, Final residual = 6.1452e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.00874565, Final residual = 0.000529739, No Iterations 5
time step continuity errors : sum local = 1.3369e-07, global = 7.83065e-09, cumulative = 3.70159e-06
GAMG: Solving for p, Initial residual = 0.00223262, Final residual = 9.18081e-07, No Iterations 23
time step continuity errors : sum local = 2.29964e-10, global = -1.07308e-11, cumulative = 3.70158e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00188824, Final residual = 6.1768e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00995918, Final residual = 6.75906e-06, No Iterations 10
ExecutionTime = 1.22 s ClockTime = 1 s
Time = 0.0775
Courant Number mean: 0.0826748 max: 0.60076
smoothSolver: Solving for Ux, Initial residual = 0.00127243, Final residual = 9.61303e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00320082, Final residual = 6.11847e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.00830737, Final residual = 0.000761114, No Iterations 3
time step continuity errors : sum local = 1.90985e-07, global = -2.38815e-08, cumulative = 3.6777e-06
GAMG: Solving for p, Initial residual = 0.00174455, Final residual = 6.60064e-07, No Iterations 26
time step continuity errors : sum local = 1.65659e-10, global = -9.2721e-12, cumulative = 3.67769e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00187133, Final residual = 5.94342e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00978506, Final residual = 6.45736e-06, No Iterations 10
ExecutionTime = 1.25 s ClockTime = 1 s
Time = 0.08
Courant Number mean: 0.0827975 max: 0.599758
smoothSolver: Solving for Ux, Initial residual = 0.00124848, Final residual = 8.7536e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00319025, Final residual = 5.54213e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.00780034, Final residual = 0.000742376, No Iterations 3
time step continuity errors : sum local = 1.86877e-07, global = 1.87491e-08, cumulative = 3.69644e-06
GAMG: Solving for p, Initial residual = 0.00183704, Final residual = 7.2529e-07, No Iterations 26
time step continuity errors : sum local = 1.82071e-10, global = 1.08528e-11, cumulative = 3.69645e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00185904, Final residual = 5.73268e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0096079, Final residual = 6.20603e-06, No Iterations 10
ExecutionTime = 1.28 s ClockTime = 1 s
Time = 0.0825
Courant Number mean: 0.0829165 max: 0.598746
smoothSolver: Solving for Ux, Initial residual = 0.00123778, Final residual = 8.94342e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00317712, Final residual = 5.41331e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.00765087, Final residual = 0.000632557, No Iterations 3
time step continuity errors : sum local = 1.58433e-07, global = -2.19335e-08, cumulative = 3.67452e-06
GAMG: Solving for p, Initial residual = 0.00147378, Final residual = 8.43196e-07, No Iterations 24
time step continuity errors : sum local = 2.11096e-10, global = -1.16646e-11, cumulative = 3.67451e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00184584, Final residual = 5.53108e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00943426, Final residual = 5.96718e-06, No Iterations 10
ExecutionTime = 1.31 s ClockTime = 1 s
Time = 0.085
Courant Number mean: 0.0830319 max: 0.597829
smoothSolver: Solving for Ux, Initial residual = 0.00121657, Final residual = 8.15629e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00315792, Final residual = 5.01307e-06, No Iterations 7
GAMG: Solving for p, Initial residual = 0.00688227, Final residual = 0.000501717, No Iterations 4
time step continuity errors : sum local = 1.25951e-07, global = 1.67388e-08, cumulative = 3.69125e-06
GAMG: Solving for p, Initial residual = 0.00157787, Final residual = 7.2176e-07, No Iterations 24
time step continuity errors : sum local = 1.80654e-10, global = 1.04908e-11, cumulative = 3.69126e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00182822, Final residual = 5.34347e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00930921, Final residual = 9.73518e-06, No Iterations 9
ExecutionTime = 1.34 s ClockTime = 1 s
Time = 0.0875
Courant Number mean: 0.083141 max: 0.596978
smoothSolver: Solving for Ux, Initial residual = 0.0012063, Final residual = 8.3277e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00313062, Final residual = 9.81203e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00657684, Final residual = 0.000636819, No Iterations 3
time step continuity errors : sum local = 1.59291e-07, global = -2.11093e-08, cumulative = 3.67015e-06
GAMG: Solving for p, Initial residual = 0.00139241, Final residual = 7.49975e-07, No Iterations 24
time step continuity errors : sum local = 1.8763e-10, global = -1.0179e-11, cumulative = 3.67014e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00180585, Final residual = 5.16338e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00920161, Final residual = 9.36259e-06, No Iterations 9
ExecutionTime = 1.36 s ClockTime = 1 s
Time = 0.09
Courant Number mean: 0.0832644 max: 0.596189
smoothSolver: Solving for Ux, Initial residual = 0.00118706, Final residual = 7.65368e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00310675, Final residual = 9.23319e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00645409, Final residual = 0.000447004, No Iterations 4
time step continuity errors : sum local = 1.12134e-07, global = 1.29826e-08, cumulative = 3.68312e-06
GAMG: Solving for p, Initial residual = 0.00148121, Final residual = 9.71758e-07, No Iterations 22
time step continuity errors : sum local = 2.43249e-10, global = 1.29384e-11, cumulative = 3.68313e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00177877, Final residual = 4.99007e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00910206, Final residual = 9.01693e-06, No Iterations 9
ExecutionTime = 1.39 s ClockTime = 1 s
Time = 0.0925
Courant Number mean: 0.0833975 max: 0.595477
smoothSolver: Solving for Ux, Initial residual = 0.0011799, Final residual = 7.77461e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00307749, Final residual = 8.95804e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00639544, Final residual = 0.000592177, No Iterations 3
time step continuity errors : sum local = 1.48151e-07, global = -1.97261e-08, cumulative = 3.66341e-06
GAMG: Solving for p, Initial residual = 0.00135681, Final residual = 6.12636e-07, No Iterations 24
time step continuity errors : sum local = 1.53269e-10, global = -8.30492e-12, cumulative = 3.6634e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00175403, Final residual = 4.82447e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00899904, Final residual = 8.69327e-06, No Iterations 9
ExecutionTime = 1.42 s ClockTime = 1 s
Time = 0.095
Courant Number mean: 0.083532 max: 0.594858
smoothSolver: Solving for Ux, Initial residual = 0.00116682, Final residual = 7.18232e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00305471, Final residual = 8.46414e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00596206, Final residual = 0.000432769, No Iterations 4
time step continuity errors : sum local = 1.08576e-07, global = 1.18539e-08, cumulative = 3.67525e-06
GAMG: Solving for p, Initial residual = 0.0013434, Final residual = 8.59625e-07, No Iterations 22
time step continuity errors : sum local = 2.15333e-10, global = 1.05535e-11, cumulative = 3.67526e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00174423, Final residual = 4.66764e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00888773, Final residual = 8.39665e-06, No Iterations 9
ExecutionTime = 1.45 s ClockTime = 1 s
Time = 0.0975
Courant Number mean: 0.0836652 max: 0.594338
smoothSolver: Solving for Ux, Initial residual = 0.00116152, Final residual = 7.26204e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00302983, Final residual = 8.26015e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00607079, Final residual = 0.000542682, No Iterations 4
time step continuity errors : sum local = 1.35992e-07, global = 1.17231e-08, cumulative = 3.68699e-06
GAMG: Solving for p, Initial residual = 0.0013356, Final residual = 7.63013e-07, No Iterations 23
time step continuity errors : sum local = 1.91382e-10, global = -8.50544e-12, cumulative = 3.68698e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00173606, Final residual = 4.52955e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00876789, Final residual = 8.12017e-06, No Iterations 9
ExecutionTime = 1.47 s ClockTime = 1 s
Time = 0.1
Courant Number mean: 0.0837953 max: 0.59392
smoothSolver: Solving for Ux, Initial residual = 0.00114992, Final residual = 6.7561e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00302959, Final residual = 7.8972e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00563856, Final residual = 0.00047173, No Iterations 4
time step continuity errors : sum local = 1.18561e-07, global = 1.07993e-08, cumulative = 3.69778e-06
GAMG: Solving for p, Initial residual = 0.00135011, Final residual = 6.4884e-07, No Iterations 24
time step continuity errors : sum local = 1.62894e-10, global = 7.77898e-12, cumulative = 3.69779e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00172557, Final residual = 4.40532e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0086468, Final residual = 7.89079e-06, No Iterations 9
ExecutionTime = 1.53 s ClockTime = 2 s
Time = 0.1025
Courant Number mean: 0.0839221 max: 0.593611
smoothSolver: Solving for Ux, Initial residual = 0.00114485, Final residual = 6.76932e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00303142, Final residual = 7.74324e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00541672, Final residual = 0.000485409, No Iterations 4
time step continuity errors : sum local = 1.21881e-07, global = 1.05674e-08, cumulative = 3.70835e-06
GAMG: Solving for p, Initial residual = 0.001276, Final residual = 9.61013e-07, No Iterations 21
time step continuity errors : sum local = 2.414e-10, global = -1.12243e-11, cumulative = 3.70834e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00171479, Final residual = 4.28552e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00852238, Final residual = 7.65215e-06, No Iterations 9
ExecutionTime = 1.55 s ClockTime = 2 s
Time = 0.105
Courant Number mean: 0.0840449 max: 0.593408
smoothSolver: Solving for Ux, Initial residual = 0.00113564, Final residual = 6.36194e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00303288, Final residual = 7.43133e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00506788, Final residual = 0.000401093, No Iterations 4
time step continuity errors : sum local = 1.00914e-07, global = 1.00146e-08, cumulative = 3.71836e-06
GAMG: Solving for p, Initial residual = 0.00123797, Final residual = 9.57876e-07, No Iterations 22
time step continuity errors : sum local = 2.40793e-10, global = 1.35657e-11, cumulative = 3.71837e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00170486, Final residual = 4.16823e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00842769, Final residual = 7.41007e-06, No Iterations 9
ExecutionTime = 1.58 s ClockTime = 2 s
Time = 0.1075
Courant Number mean: 0.0841641 max: 0.593307
smoothSolver: Solving for Ux, Initial residual = 0.00113043, Final residual = 6.33796e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.0030262, Final residual = 7.27482e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00491139, Final residual = 0.000422105, No Iterations 4
time step continuity errors : sum local = 1.06118e-07, global = 1.02061e-08, cumulative = 3.72858e-06
GAMG: Solving for p, Initial residual = 0.00113329, Final residual = 8.3319e-07, No Iterations 21
time step continuity errors : sum local = 2.0951e-10, global = -9.71835e-12, cumulative = 3.72857e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00169634, Final residual = 9.79597e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00834623, Final residual = 7.16855e-06, No Iterations 9
ExecutionTime = 1.61 s ClockTime = 2 s
Time = 0.11
Courant Number mean: 0.0842792 max: 0.593301
smoothSolver: Solving for Ux, Initial residual = 0.00112293, Final residual = 5.99739e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00301531, Final residual = 7.00729e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00470549, Final residual = 0.000357952, No Iterations 4
time step continuity errors : sum local = 9.00885e-08, global = 9.83792e-09, cumulative = 3.7384e-06
GAMG: Solving for p, Initial residual = 0.00109215, Final residual = 9.79068e-07, No Iterations 22
time step continuity errors : sum local = 2.46213e-10, global = 1.55586e-11, cumulative = 3.73842e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00169063, Final residual = 9.57997e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00827421, Final residual = 6.95586e-06, No Iterations 9
ExecutionTime = 1.64 s ClockTime = 2 s
Time = 0.1125
Courant Number mean: 0.0843902 max: 0.593383
smoothSolver: Solving for Ux, Initial residual = 0.0011185, Final residual = 5.94158e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00299935, Final residual = 6.84803e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00450388, Final residual = 0.000381521, No Iterations 4
time step continuity errors : sum local = 9.59232e-08, global = 9.45379e-09, cumulative = 3.74787e-06
GAMG: Solving for p, Initial residual = 0.00104448, Final residual = 7.76364e-07, No Iterations 21
time step continuity errors : sum local = 1.95199e-10, global = -9.12301e-12, cumulative = 3.74786e-06
smoothSolver: Solving for epsilon, Initial residual = 0.001683, Final residual = 9.35665e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00820293, Final residual = 6.75134e-06, No Iterations 9
ExecutionTime = 1.67 s ClockTime = 2 s
Time = 0.115
Courant Number mean: 0.0844961 max: 0.593545
smoothSolver: Solving for Ux, Initial residual = 0.00111211, Final residual = 5.64348e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00298839, Final residual = 6.60188e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00435998, Final residual = 0.000329091, No Iterations 4
time step continuity errors : sum local = 8.28026e-08, global = 9.6509e-09, cumulative = 3.75751e-06
GAMG: Solving for p, Initial residual = 0.000998854, Final residual = 6.58396e-07, No Iterations 24
time step continuity errors : sum local = 1.6555e-10, global = 1.46466e-11, cumulative = 3.75753e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00167921, Final residual = 9.13525e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00812633, Final residual = 6.55688e-06, No Iterations 9
ExecutionTime = 1.7 s ClockTime = 2 s
Time = 0.1175
Courant Number mean: 0.084595 max: 0.593777
smoothSolver: Solving for Ux, Initial residual = 0.00110764, Final residual = 5.56582e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00297686, Final residual = 6.44419e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00429835, Final residual = 0.000353328, No Iterations 4
time step continuity errors : sum local = 8.8844e-08, global = 9.12036e-09, cumulative = 3.76665e-06
GAMG: Solving for p, Initial residual = 0.000995022, Final residual = 6.86738e-07, No Iterations 21
time step continuity errors : sum local = 1.72686e-10, global = -8.49469e-12, cumulative = 3.76664e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00167291, Final residual = 8.92673e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00804056, Final residual = 6.37119e-06, No Iterations 9
ExecutionTime = 1.72 s ClockTime = 2 s
Time = 0.12
Courant Number mean: 0.0846861 max: 0.594071
smoothSolver: Solving for Ux, Initial residual = 0.00110166, Final residual = 5.30427e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00296183, Final residual = 6.23307e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00447884, Final residual = 0.000339856, No Iterations 4
time step continuity errors : sum local = 8.55301e-08, global = 1.02618e-08, cumulative = 3.7769e-06
GAMG: Solving for p, Initial residual = 0.00104836, Final residual = 9.89663e-07, No Iterations 23
time step continuity errors : sum local = 2.48938e-10, global = -4.4281e-11, cumulative = 3.77686e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00166523, Final residual = 8.73144e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00794813, Final residual = 6.20207e-06, No Iterations 9
ExecutionTime = 1.75 s ClockTime = 2 s
Time = 0.1225
Courant Number mean: 0.0847692 max: 0.594416
smoothSolver: Solving for Ux, Initial residual = 0.00109825, Final residual = 5.21298e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00294097, Final residual = 6.10037e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00408188, Final residual = 0.000335719, No Iterations 4
time step continuity errors : sum local = 8.44892e-08, global = 8.99355e-09, cumulative = 3.78585e-06
GAMG: Solving for p, Initial residual = 0.000990185, Final residual = 7.4852e-07, No Iterations 21
time step continuity errors : sum local = 1.88428e-10, global = -9.9349e-12, cumulative = 3.78584e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00165797, Final residual = 8.53738e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00786381, Final residual = 6.05395e-06, No Iterations 9
ExecutionTime = 1.78 s ClockTime = 2 s
Time = 0.125
Courant Number mean: 0.0848517 max: 0.594802
smoothSolver: Solving for Ux, Initial residual = 0.00109498, Final residual = 4.98113e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00293509, Final residual = 5.91654e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00431308, Final residual = 0.000331594, No Iterations 4
time step continuity errors : sum local = 8.35457e-08, global = 9.06333e-09, cumulative = 3.79491e-06
GAMG: Solving for p, Initial residual = 0.0009941, Final residual = 6.90351e-07, No Iterations 24
time step continuity errors : sum local = 1.73884e-10, global = 1.96417e-11, cumulative = 3.79493e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00165191, Final residual = 8.37342e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0077951, Final residual = 5.89468e-06, No Iterations 9
ExecutionTime = 1.81 s ClockTime = 2 s
Time = 0.1275
Courant Number mean: 0.0849488 max: 0.59522
smoothSolver: Solving for Ux, Initial residual = 0.00109255, Final residual = 4.88276e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00294139, Final residual = 5.7819e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00450533, Final residual = 0.000335252, No Iterations 4
time step continuity errors : sum local = 8.44958e-08, global = 8.24581e-09, cumulative = 3.80317e-06
GAMG: Solving for p, Initial residual = 0.00099866, Final residual = 7.14291e-07, No Iterations 21
time step continuity errors : sum local = 1.80071e-10, global = -8.7481e-12, cumulative = 3.80316e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00164671, Final residual = 8.19879e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00773377, Final residual = 9.80144e-06, No Iterations 8
ExecutionTime = 1.84 s ClockTime = 2 s
Time = 0.13
Courant Number mean: 0.0850503 max: 0.59566
smoothSolver: Solving for Ux, Initial residual = 0.00108937, Final residual = 4.67674e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00294751, Final residual = 5.60423e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00436109, Final residual = 0.000349154, No Iterations 4
time step continuity errors : sum local = 8.80937e-08, global = 8.21666e-09, cumulative = 3.81138e-06
GAMG: Solving for p, Initial residual = 0.000985699, Final residual = 9.45188e-07, No Iterations 23
time step continuity errors : sum local = 2.3841e-10, global = -4.42761e-11, cumulative = 3.81133e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00164421, Final residual = 8.02988e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00767557, Final residual = 9.51165e-06, No Iterations 8
ExecutionTime = 1.87 s ClockTime = 2 s
Time = 0.1325
Courant Number mean: 0.0851533 max: 0.596114
smoothSolver: Solving for Ux, Initial residual = 0.00108717, Final residual = 4.58652e-06, No Iterations 5
smoothSolver: Solving for Uy, Initial residual = 0.00294784, Final residual = 5.46364e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00411767, Final residual = 0.000352507, No Iterations 4
time step continuity errors : sum local = 8.89107e-08, global = 7.63117e-09, cumulative = 3.81897e-06
GAMG: Solving for p, Initial residual = 0.0009668, Final residual = 7.54555e-07, No Iterations 21
time step continuity errors : sum local = 1.90279e-10, global = -1.12095e-11, cumulative = 3.81895e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00164228, Final residual = 7.86399e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00761229, Final residual = 9.22997e-06, No Iterations 8
ExecutionTime = 1.9 s ClockTime = 2 s
Time = 0.135
Courant Number mean: 0.0852557 max: 0.596574
smoothSolver: Solving for Ux, Initial residual = 0.00108407, Final residual = 9.95044e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00294365, Final residual = 5.29151e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00414954, Final residual = 0.000206444, No Iterations 5
time step continuity errors : sum local = 5.20751e-08, global = 4.80311e-09, cumulative = 3.82376e-06
GAMG: Solving for p, Initial residual = 0.00101482, Final residual = 8.76142e-07, No Iterations 22
time step continuity errors : sum local = 2.20776e-10, global = 2.04318e-11, cumulative = 3.82378e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00163791, Final residual = 7.69878e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.007545, Final residual = 8.96054e-06, No Iterations 8
ExecutionTime = 1.92 s ClockTime = 2 s
Time = 0.1375
Courant Number mean: 0.0853575 max: 0.597029
smoothSolver: Solving for Ux, Initial residual = 0.00108158, Final residual = 9.84208e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00293209, Final residual = 5.1636e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00399231, Final residual = 0.000367734, No Iterations 4
time step continuity errors : sum local = 9.26748e-08, global = 5.96469e-09, cumulative = 3.82974e-06
GAMG: Solving for p, Initial residual = 0.00100737, Final residual = 6.52291e-07, No Iterations 21
time step continuity errors : sum local = 1.64343e-10, global = -8.00437e-12, cumulative = 3.82974e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00163481, Final residual = 7.53367e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00747394, Final residual = 8.70233e-06, No Iterations 8
ExecutionTime = 1.95 s ClockTime = 2 s
Time = 0.14
Courant Number mean: 0.0854579 max: 0.597479
smoothSolver: Solving for Ux, Initial residual = 0.0010773, Final residual = 9.49233e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00291875, Final residual = 4.96451e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00370069, Final residual = 0.000209688, No Iterations 5
time step continuity errors : sum local = 5.28284e-08, global = 1.7183e-09, cumulative = 3.83145e-06
GAMG: Solving for p, Initial residual = 0.000910219, Final residual = 9.51079e-07, No Iterations 22
time step continuity errors : sum local = 2.39375e-10, global = 1.8855e-11, cumulative = 3.83147e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00163048, Final residual = 7.37007e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00739779, Final residual = 8.45729e-06, No Iterations 8
ExecutionTime = 1.98 s ClockTime = 2 s
Time = 0.1425
Courant Number mean: 0.0855564 max: 0.597915
smoothSolver: Solving for Ux, Initial residual = 0.00107396, Final residual = 9.32311e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00291213, Final residual = 4.84229e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00368403, Final residual = 0.00036275, No Iterations 4
time step continuity errors : sum local = 9.12562e-08, global = 4.29531e-09, cumulative = 3.83577e-06
GAMG: Solving for p, Initial residual = 0.000935013, Final residual = 6.76141e-07, No Iterations 21
time step continuity errors : sum local = 1.69969e-10, global = -9.56674e-12, cumulative = 3.83576e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00162682, Final residual = 7.2111e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00731954, Final residual = 8.23165e-06, No Iterations 8
ExecutionTime = 2 s ClockTime = 2 s
Time = 0.145
Courant Number mean: 0.0856515 max: 0.598335
smoothSolver: Solving for Ux, Initial residual = 0.00107007, Final residual = 9.02986e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00290495, Final residual = 4.66626e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00375239, Final residual = 0.00036167, No Iterations 4
time step continuity errors : sum local = 9.091e-08, global = 2.38574e-09, cumulative = 3.83814e-06
GAMG: Solving for p, Initial residual = 0.000938117, Final residual = 9.55714e-07, No Iterations 23
time step continuity errors : sum local = 2.40029e-10, global = -4.77601e-11, cumulative = 3.8381e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0016245, Final residual = 7.06909e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0072682, Final residual = 8.05059e-06, No Iterations 8
ExecutionTime = 2.03 s ClockTime = 2 s
Time = 0.1475
Courant Number mean: 0.0857417 max: 0.598734
smoothSolver: Solving for Ux, Initial residual = 0.00106694, Final residual = 8.85727e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00288922, Final residual = 4.54958e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00357231, Final residual = 0.000340483, No Iterations 4
time step continuity errors : sum local = 8.54993e-08, global = 2.97011e-09, cumulative = 3.84107e-06
GAMG: Solving for p, Initial residual = 0.000920546, Final residual = 7.3915e-07, No Iterations 21
time step continuity errors : sum local = 1.85525e-10, global = -1.52732e-11, cumulative = 3.84105e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00162133, Final residual = 6.94127e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00722855, Final residual = 7.84324e-06, No Iterations 8
ExecutionTime = 2.06 s ClockTime = 2 s
Time = 0.15
Courant Number mean: 0.085826 max: 0.599108
smoothSolver: Solving for Ux, Initial residual = 0.00106438, Final residual = 8.58669e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00287231, Final residual = 4.40622e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00354183, Final residual = 0.000186424, No Iterations 5
time step continuity errors : sum local = 4.68101e-08, global = 2.45855e-09, cumulative = 3.84351e-06
GAMG: Solving for p, Initial residual = 0.000910422, Final residual = 8.73576e-07, No Iterations 22
time step continuity errors : sum local = 2.19258e-10, global = 1.81031e-11, cumulative = 3.84353e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00161769, Final residual = 6.81293e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00718998, Final residual = 7.63133e-06, No Iterations 8
ExecutionTime = 2.09 s ClockTime = 2 s
Time = 0.1525
Courant Number mean: 0.0859043 max: 0.599455
smoothSolver: Solving for Ux, Initial residual = 0.0010634, Final residual = 8.40846e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00287316, Final residual = 4.29559e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00362256, Final residual = 0.000333581, No Iterations 4
time step continuity errors : sum local = 8.37431e-08, global = 2.40608e-09, cumulative = 3.84593e-06
GAMG: Solving for p, Initial residual = 0.000923635, Final residual = 7.53661e-07, No Iterations 22
time step continuity errors : sum local = 1.8915e-10, global = 2.67255e-11, cumulative = 3.84596e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00161462, Final residual = 6.68305e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00714637, Final residual = 7.41968e-06, No Iterations 8
ExecutionTime = 2.12 s ClockTime = 2 s
Time = 0.155
Courant Number mean: 0.0859764 max: 0.599772
smoothSolver: Solving for Ux, Initial residual = 0.00106225, Final residual = 8.16969e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00287862, Final residual = 9.89699e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.003609, Final residual = 0.000210768, No Iterations 5
time step continuity errors : sum local = 5.29206e-08, global = 2.23659e-09, cumulative = 3.8482e-06
GAMG: Solving for p, Initial residual = 0.00087504, Final residual = 9.24064e-07, No Iterations 22
time step continuity errors : sum local = 2.31968e-10, global = 2.27833e-11, cumulative = 3.84822e-06
smoothSolver: Solving for epsilon, Initial residual = 0.001613, Final residual = 6.55053e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00709594, Final residual = 7.21576e-06, No Iterations 8
ExecutionTime = 2.15 s ClockTime = 2 s
Time = 0.1575
Courant Number mean: 0.0860423 max: 0.60006
smoothSolver: Solving for Ux, Initial residual = 0.0010611, Final residual = 7.9911e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0028819, Final residual = 9.70764e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00349876, Final residual = 0.000214368, No Iterations 5
time step continuity errors : sum local = 5.38187e-08, global = 1.02035e-09, cumulative = 3.84924e-06
GAMG: Solving for p, Initial residual = 0.000859684, Final residual = 6.93866e-07, No Iterations 22
time step continuity errors : sum local = 1.74167e-10, global = 2.49956e-11, cumulative = 3.84927e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00161121, Final residual = 6.41742e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.007041, Final residual = 7.01477e-06, No Iterations 8
ExecutionTime = 2.18 s ClockTime = 2 s
Time = 0.16
Courant Number mean: 0.0861081 max: 0.600319
smoothSolver: Solving for Ux, Initial residual = 0.00105907, Final residual = 7.77877e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00287946, Final residual = 9.45177e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00356159, Final residual = 0.000212012, No Iterations 5
time step continuity errors : sum local = 5.32226e-08, global = 2.39282e-09, cumulative = 3.85166e-06
GAMG: Solving for p, Initial residual = 0.000854724, Final residual = 8.2676e-07, No Iterations 22
time step continuity errors : sum local = 2.07469e-10, global = 2.26417e-11, cumulative = 3.85168e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00160931, Final residual = 6.28545e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00698274, Final residual = 6.82342e-06, No Iterations 8
ExecutionTime = 2.21 s ClockTime = 2 s
Time = 0.1625
Courant Number mean: 0.0861865 max: 0.600549
smoothSolver: Solving for Ux, Initial residual = 0.00105664, Final residual = 7.61489e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00287126, Final residual = 9.232e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00347181, Final residual = 0.000338277, No Iterations 4
time step continuity errors : sum local = 8.48846e-08, global = 6.59651e-10, cumulative = 3.85234e-06
GAMG: Solving for p, Initial residual = 0.000870292, Final residual = 9.63725e-07, No Iterations 22
time step continuity errors : sum local = 2.41747e-10, global = 2.82979e-11, cumulative = 3.85237e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0016081, Final residual = 6.15673e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00691988, Final residual = 6.64059e-06, No Iterations 8
ExecutionTime = 2.24 s ClockTime = 2 s
Time = 0.165
Courant Number mean: 0.0862694 max: 0.600752
smoothSolver: Solving for Ux, Initial residual = 0.00105358, Final residual = 7.44008e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00285855, Final residual = 8.99176e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0033537, Final residual = 0.000325296, No Iterations 4
time step continuity errors : sum local = 8.15782e-08, global = -7.26261e-10, cumulative = 3.85164e-06
GAMG: Solving for p, Initial residual = 0.000835359, Final residual = 6.90176e-07, No Iterations 22
time step continuity errors : sum local = 1.72989e-10, global = 2.49667e-11, cumulative = 3.85167e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0016087, Final residual = 6.03765e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00685648, Final residual = 6.46933e-06, No Iterations 8
ExecutionTime = 2.27 s ClockTime = 2 s
Time = 0.1675
Courant Number mean: 0.0863545 max: 0.600929
smoothSolver: Solving for Ux, Initial residual = 0.00105068, Final residual = 7.27358e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00284364, Final residual = 8.78318e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00321077, Final residual = 0.000311229, No Iterations 4
time step continuity errors : sum local = 7.79816e-08, global = -1.06763e-09, cumulative = 3.8506e-06
GAMG: Solving for p, Initial residual = 0.000792985, Final residual = 8.89677e-07, No Iterations 20
time step continuity errors : sum local = 2.22771e-10, global = 3.76431e-11, cumulative = 3.85064e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00160885, Final residual = 5.92576e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00681323, Final residual = 6.31452e-06, No Iterations 8
ExecutionTime = 2.3 s ClockTime = 2 s
Time = 0.17
Courant Number mean: 0.0864405 max: 0.601081
smoothSolver: Solving for Ux, Initial residual = 0.00104821, Final residual = 7.10782e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0028383, Final residual = 8.56177e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00323611, Final residual = 0.000303202, No Iterations 4
time step continuity errors : sum local = 7.58851e-08, global = -1.45003e-09, cumulative = 3.84919e-06
GAMG: Solving for p, Initial residual = 0.000774689, Final residual = 8.26727e-07, No Iterations 20
time step continuity errors : sum local = 2.06767e-10, global = -3.25305e-11, cumulative = 3.84915e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00160712, Final residual = 5.81925e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00678225, Final residual = 6.15445e-06, No Iterations 8
ExecutionTime = 2.32 s ClockTime = 2 s
Time = 0.1725
Courant Number mean: 0.086527 max: 0.601211
smoothSolver: Solving for Ux, Initial residual = 0.00104592, Final residual = 6.94695e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00283202, Final residual = 8.35086e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00327734, Final residual = 0.00029265, No Iterations 4
time step continuity errors : sum local = 7.31684e-08, global = -1.79976e-09, cumulative = 3.84735e-06
GAMG: Solving for p, Initial residual = 0.00075689, Final residual = 7.00547e-07, No Iterations 21
time step continuity errors : sum local = 1.75041e-10, global = 2.76734e-11, cumulative = 3.84738e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00160403, Final residual = 5.71585e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00675217, Final residual = 5.99072e-06, No Iterations 8
ExecutionTime = 2.35 s ClockTime = 2 s
Time = 0.175
Courant Number mean: 0.0866121 max: 0.601322
smoothSolver: Solving for Ux, Initial residual = 0.00104386, Final residual = 6.78557e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00282052, Final residual = 8.14316e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00299509, Final residual = 0.000290107, No Iterations 4
time step continuity errors : sum local = 7.24764e-08, global = -1.8617e-09, cumulative = 3.84552e-06
GAMG: Solving for p, Initial residual = 0.000716509, Final residual = 7.97429e-07, No Iterations 21
time step continuity errors : sum local = 1.99113e-10, global = 2.62352e-11, cumulative = 3.84555e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00160018, Final residual = 5.6045e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00671977, Final residual = 5.82542e-06, No Iterations 8
ExecutionTime = 2.38 s ClockTime = 2 s
Time = 0.1775
Courant Number mean: 0.0866942 max: 0.601417
smoothSolver: Solving for Ux, Initial residual = 0.0010422, Final residual = 6.63376e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0028089, Final residual = 7.9585e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00298675, Final residual = 0.000284604, No Iterations 4
time step continuity errors : sum local = 7.10646e-08, global = -2.25667e-09, cumulative = 3.84329e-06
GAMG: Solving for p, Initial residual = 0.000727945, Final residual = 7.78514e-07, No Iterations 21
time step continuity errors : sum local = 1.94321e-10, global = 2.85268e-11, cumulative = 3.84332e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00159649, Final residual = 5.4902e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00668216, Final residual = 9.93013e-06, No Iterations 7
ExecutionTime = 2.4 s ClockTime = 2 s
Time = 0.18
Courant Number mean: 0.0867727 max: 0.601498
smoothSolver: Solving for Ux, Initial residual = 0.00104117, Final residual = 6.48309e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00281243, Final residual = 7.78333e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00320383, Final residual = 0.000279341, No Iterations 4
time step continuity errors : sum local = 6.97351e-08, global = -2.50615e-09, cumulative = 3.84081e-06
GAMG: Solving for p, Initial residual = 0.00075592, Final residual = 8.6515e-07, No Iterations 21
time step continuity errors : sum local = 2.15914e-10, global = 2.64464e-11, cumulative = 3.84084e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00159199, Final residual = 5.37532e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00664087, Final residual = 9.64212e-06, No Iterations 7
ExecutionTime = 2.43 s ClockTime = 2 s
Time = 0.1825
Courant Number mean: 0.0868469 max: 0.601566
smoothSolver: Solving for Ux, Initial residual = 0.00104048, Final residual = 6.34032e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00281857, Final residual = 7.6176e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00319873, Final residual = 0.000273128, No Iterations 4
time step continuity errors : sum local = 6.8183e-08, global = -2.58215e-09, cumulative = 3.83826e-06
GAMG: Solving for p, Initial residual = 0.000742907, Final residual = 8.48362e-07, No Iterations 21
time step continuity errors : sum local = 2.11753e-10, global = 2.73711e-11, cumulative = 3.83828e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00159129, Final residual = 5.26372e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00659545, Final residual = 9.35846e-06, No Iterations 7
ExecutionTime = 2.46 s ClockTime = 2 s
Time = 0.185
Courant Number mean: 0.0869167 max: 0.601625
smoothSolver: Solving for Ux, Initial residual = 0.00103976, Final residual = 6.19791e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00282144, Final residual = 7.45548e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00319515, Final residual = 0.000270452, No Iterations 4
time step continuity errors : sum local = 6.75254e-08, global = -2.9431e-09, cumulative = 3.83534e-06
GAMG: Solving for p, Initial residual = 0.000734736, Final residual = 9.36453e-07, No Iterations 21
time step continuity errors : sum local = 2.33787e-10, global = 2.81379e-11, cumulative = 3.83537e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00159094, Final residual = 5.15955e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00654633, Final residual = 9.09206e-06, No Iterations 7
ExecutionTime = 2.49 s ClockTime = 3 s
Time = 0.1875
Courant Number mean: 0.0869822 max: 0.601676
smoothSolver: Solving for Ux, Initial residual = 0.00103869, Final residual = 6.06911e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00281977, Final residual = 7.30006e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00303296, Final residual = 0.000264688, No Iterations 4
time step continuity errors : sum local = 6.6097e-08, global = -2.78883e-09, cumulative = 3.83258e-06
GAMG: Solving for p, Initial residual = 0.00070996, Final residual = 8.90473e-07, No Iterations 21
time step continuity errors : sum local = 2.22353e-10, global = 2.67449e-11, cumulative = 3.83261e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00159223, Final residual = 5.06032e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00649451, Final residual = 8.84004e-06, No Iterations 7
ExecutionTime = 2.52 s ClockTime = 3 s
Time = 0.19
Courant Number mean: 0.0870436 max: 0.601723
smoothSolver: Solving for Ux, Initial residual = 0.00103699, Final residual = 5.943e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00281278, Final residual = 7.14466e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00301302, Final residual = 0.000262441, No Iterations 4
time step continuity errors : sum local = 6.55451e-08, global = -2.88146e-09, cumulative = 3.82973e-06
GAMG: Solving for p, Initial residual = 0.000694903, Final residual = 9.35594e-07, No Iterations 21
time step continuity errors : sum local = 2.33637e-10, global = 2.69931e-11, cumulative = 3.82975e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0015921, Final residual = 4.96624e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00645621, Final residual = 8.59598e-06, No Iterations 7
ExecutionTime = 2.55 s ClockTime = 3 s
Time = 0.1925
Courant Number mean: 0.087101 max: 0.601767
smoothSolver: Solving for Ux, Initial residual = 0.00103498, Final residual = 5.82208e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00280064, Final residual = 6.99199e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00295826, Final residual = 0.00025842, No Iterations 4
time step continuity errors : sum local = 6.45431e-08, global = -2.552e-09, cumulative = 3.8272e-06
GAMG: Solving for p, Initial residual = 0.00067656, Final residual = 8.8833e-07, No Iterations 21
time step continuity errors : sum local = 2.21837e-10, global = 2.72391e-11, cumulative = 3.82723e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00159046, Final residual = 4.8704e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00642848, Final residual = 8.37696e-06, No Iterations 7
ExecutionTime = 2.57 s ClockTime = 3 s
Time = 0.195
Courant Number mean: 0.087156 max: 0.601816
smoothSolver: Solving for Ux, Initial residual = 0.00103314, Final residual = 5.70116e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00278805, Final residual = 6.8397e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00292564, Final residual = 0.000254126, No Iterations 4
time step continuity errors : sum local = 6.34592e-08, global = -2.56013e-09, cumulative = 3.82467e-06
GAMG: Solving for p, Initial residual = 0.000658684, Final residual = 9.091e-07, No Iterations 21
time step continuity errors : sum local = 2.2695e-10, global = 2.74505e-11, cumulative = 3.8247e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0015875, Final residual = 4.77503e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00640381, Final residual = 8.143e-06, No Iterations 7
ExecutionTime = 2.6 s ClockTime = 3 s
Time = 0.1975
Courant Number mean: 0.087222 max: 0.601874
smoothSolver: Solving for Ux, Initial residual = 0.00103137, Final residual = 5.5835e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00278419, Final residual = 6.69382e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00279863, Final residual = 0.000250843, No Iterations 4
time step continuity errors : sum local = 6.26134e-08, global = -2.25129e-09, cumulative = 3.82244e-06
GAMG: Solving for p, Initial residual = 0.000642636, Final residual = 9.02627e-07, No Iterations 21
time step continuity errors : sum local = 2.25237e-10, global = 2.70722e-11, cumulative = 3.82247e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00158307, Final residual = 4.67767e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0063774, Final residual = 7.90823e-06, No Iterations 7
ExecutionTime = 2.62 s ClockTime = 3 s
Time = 0.2
Courant Number mean: 0.0872933 max: 0.601933
smoothSolver: Solving for Ux, Initial residual = 0.00102952, Final residual = 5.4657e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00277632, Final residual = 6.54903e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00276398, Final residual = 0.000249526, No Iterations 4
time step continuity errors : sum local = 6.2251e-08, global = -2.20507e-09, cumulative = 3.82027e-06
GAMG: Solving for p, Initial residual = 0.000625054, Final residual = 8.98449e-07, No Iterations 21
time step continuity errors : sum local = 2.24051e-10, global = 2.61166e-11, cumulative = 3.82029e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00157821, Final residual = 4.57435e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00634828, Final residual = 7.67473e-06, No Iterations 7
ExecutionTime = 2.68 s ClockTime = 3 s
Time = 0.2025
Courant Number mean: 0.0873674 max: 0.601994
smoothSolver: Solving for Ux, Initial residual = 0.00102784, Final residual = 5.34947e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00276168, Final residual = 6.41194e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00260239, Final residual = 0.000247281, No Iterations 4
time step continuity errors : sum local = 6.16659e-08, global = -2.27953e-09, cumulative = 3.81801e-06
GAMG: Solving for p, Initial residual = 0.000609028, Final residual = 9.15651e-07, No Iterations 21
time step continuity errors : sum local = 2.28294e-10, global = 2.65589e-11, cumulative = 3.81804e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00157352, Final residual = 4.47402e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00631361, Final residual = 7.44115e-06, No Iterations 7
ExecutionTime = 2.71 s ClockTime = 3 s
Time = 0.205
Courant Number mean: 0.0874425 max: 0.60206
smoothSolver: Solving for Ux, Initial residual = 0.00102599, Final residual = 5.23475e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00274512, Final residual = 6.28461e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00248829, Final residual = 0.000243188, No Iterations 4
time step continuity errors : sum local = 6.06408e-08, global = -2.23543e-09, cumulative = 3.8158e-06
GAMG: Solving for p, Initial residual = 0.000589788, Final residual = 9.04167e-07, No Iterations 21
time step continuity errors : sum local = 2.25429e-10, global = 2.56559e-11, cumulative = 3.81583e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00156966, Final residual = 4.37927e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00627402, Final residual = 7.21231e-06, No Iterations 7
ExecutionTime = 2.73 s ClockTime = 3 s
Time = 0.2075
Courant Number mean: 0.0875171 max: 0.602129
smoothSolver: Solving for Ux, Initial residual = 0.00102462, Final residual = 5.12119e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00274255, Final residual = 6.16243e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00253057, Final residual = 0.000238677, No Iterations 4
time step continuity errors : sum local = 5.95138e-08, global = -2.25799e-09, cumulative = 3.81357e-06
GAMG: Solving for p, Initial residual = 0.000597674, Final residual = 8.91131e-07, No Iterations 21
time step continuity errors : sum local = 2.22164e-10, global = 2.53223e-11, cumulative = 3.8136e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00156823, Final residual = 4.28441e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00623193, Final residual = 6.99275e-06, No Iterations 7
ExecutionTime = 2.76 s ClockTime = 3 s
Time = 0.21
Courant Number mean: 0.0875901 max: 0.602203
smoothSolver: Solving for Ux, Initial residual = 0.00102376, Final residual = 5.01199e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00274438, Final residual = 6.04433e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00262781, Final residual = 0.000237721, No Iterations 4
time step continuity errors : sum local = 5.92714e-08, global = -2.25272e-09, cumulative = 3.81134e-06
GAMG: Solving for p, Initial residual = 0.00061995, Final residual = 8.82646e-07, No Iterations 21
time step continuity errors : sum local = 2.2003e-10, global = 2.50206e-11, cumulative = 3.81137e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00156768, Final residual = 4.20226e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0061878, Final residual = 6.78856e-06, No Iterations 7
ExecutionTime = 2.79 s ClockTime = 3 s
Time = 0.2125
Courant Number mean: 0.0876605 max: 0.602283
smoothSolver: Solving for Ux, Initial residual = 0.00102322, Final residual = 4.90669e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00274393, Final residual = 5.9295e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00253172, Final residual = 0.00023839, No Iterations 4
time step continuity errors : sum local = 5.94367e-08, global = -2.21558e-09, cumulative = 3.80915e-06
GAMG: Solving for p, Initial residual = 0.00060717, Final residual = 8.66431e-07, No Iterations 21
time step continuity errors : sum local = 2.15999e-10, global = 2.4288e-11, cumulative = 3.80918e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00156646, Final residual = 4.12105e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00614907, Final residual = 6.59445e-06, No Iterations 7
ExecutionTime = 2.82 s ClockTime = 3 s
Time = 0.215
Courant Number mean: 0.0877284 max: 0.602369
smoothSolver: Solving for Ux, Initial residual = 0.0010228, Final residual = 4.80813e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00274033, Final residual = 5.81623e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00258181, Final residual = 0.000243192, No Iterations 4
time step continuity errors : sum local = 6.06401e-08, global = -2.13817e-09, cumulative = 3.80704e-06
GAMG: Solving for p, Initial residual = 0.00061428, Final residual = 8.81695e-07, No Iterations 21
time step continuity errors : sum local = 2.19844e-10, global = 2.51054e-11, cumulative = 3.80706e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00156481, Final residual = 4.04027e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0061229, Final residual = 6.40562e-06, No Iterations 7
ExecutionTime = 2.85 s ClockTime = 3 s
Time = 0.2175
Courant Number mean: 0.0877934 max: 0.60246
smoothSolver: Solving for Ux, Initial residual = 0.00102203, Final residual = 4.71196e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00273372, Final residual = 5.7026e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00266009, Final residual = 0.000250076, No Iterations 4
time step continuity errors : sum local = 6.23724e-08, global = -2.04661e-09, cumulative = 3.80502e-06
GAMG: Solving for p, Initial residual = 0.000616595, Final residual = 8.64226e-07, No Iterations 21
time step continuity errors : sum local = 2.15565e-10, global = 2.44768e-11, cumulative = 3.80504e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00156228, Final residual = 3.95762e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00609961, Final residual = 6.22372e-06, No Iterations 7
ExecutionTime = 2.87 s ClockTime = 3 s
Time = 0.22
Courant Number mean: 0.0878556 max: 0.602558
smoothSolver: Solving for Ux, Initial residual = 0.0010212, Final residual = 4.61692e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00272438, Final residual = 5.58884e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00258898, Final residual = 0.000244065, No Iterations 4
time step continuity errors : sum local = 6.0881e-08, global = -2.08625e-09, cumulative = 3.80296e-06
GAMG: Solving for p, Initial residual = 0.000603564, Final residual = 8.50529e-07, No Iterations 21
time step continuity errors : sum local = 2.12136e-10, global = 2.4065e-11, cumulative = 3.80298e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00155893, Final residual = 3.87483e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00607853, Final residual = 6.05301e-06, No Iterations 7
ExecutionTime = 2.9 s ClockTime = 3 s
Time = 0.2225
Courant Number mean: 0.0879152 max: 0.602661
smoothSolver: Solving for Ux, Initial residual = 0.00102067, Final residual = 4.52359e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00271609, Final residual = 5.47533e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00245852, Final residual = 0.000236632, No Iterations 4
time step continuity errors : sum local = 5.90242e-08, global = -2.0333e-09, cumulative = 3.80095e-06
GAMG: Solving for p, Initial residual = 0.000585698, Final residual = 8.34554e-07, No Iterations 21
time step continuity errors : sum local = 2.08146e-10, global = 2.37209e-11, cumulative = 3.80097e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00155438, Final residual = 3.79189e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00605651, Final residual = 5.87761e-06, No Iterations 7
ExecutionTime = 2.92 s ClockTime = 3 s
Time = 0.225
Courant Number mean: 0.0879722 max: 0.60277
smoothSolver: Solving for Ux, Initial residual = 0.00102016, Final residual = 4.43216e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00271427, Final residual = 5.363e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00242264, Final residual = 0.000228382, No Iterations 4
time step continuity errors : sum local = 5.69666e-08, global = -2.05119e-09, cumulative = 3.79892e-06
GAMG: Solving for p, Initial residual = 0.000574125, Final residual = 8.08591e-07, No Iterations 21
time step continuity errors : sum local = 2.01679e-10, global = 2.27064e-11, cumulative = 3.79894e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00154924, Final residual = 3.71086e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00603327, Final residual = 5.70528e-06, No Iterations 7
ExecutionTime = 2.95 s ClockTime = 3 s
Time = 0.2275
Courant Number mean: 0.0880269 max: 0.602884
smoothSolver: Solving for Ux, Initial residual = 0.00101952, Final residual = 4.34202e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00270993, Final residual = 5.25323e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00245111, Final residual = 0.000224822, No Iterations 4
time step continuity errors : sum local = 5.60769e-08, global = -2.15336e-09, cumulative = 3.79679e-06
GAMG: Solving for p, Initial residual = 0.000569196, Final residual = 8.00792e-07, No Iterations 21
time step continuity errors : sum local = 1.99721e-10, global = 2.2878e-11, cumulative = 3.79681e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00154566, Final residual = 3.63043e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00600541, Final residual = 5.53748e-06, No Iterations 7
ExecutionTime = 2.97 s ClockTime = 3 s
Time = 0.23
Courant Number mean: 0.0880799 max: 0.603004
smoothSolver: Solving for Ux, Initial residual = 0.00101874, Final residual = 4.25429e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00269931, Final residual = 5.1518e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00232736, Final residual = 0.000219105, No Iterations 4
time step continuity errors : sum local = 5.46509e-08, global = -2.03276e-09, cumulative = 3.79478e-06
GAMG: Solving for p, Initial residual = 0.000548699, Final residual = 7.97184e-07, No Iterations 21
time step continuity errors : sum local = 1.98843e-10, global = 2.293e-11, cumulative = 3.7948e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00154295, Final residual = 3.55376e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00597096, Final residual = 5.36951e-06, No Iterations 7
ExecutionTime = 3 s ClockTime = 3 s
Time = 0.2325
Courant Number mean: 0.0881321 max: 0.603128
smoothSolver: Solving for Ux, Initial residual = 0.00101762, Final residual = 4.16663e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00268269, Final residual = 5.05605e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00230836, Final residual = 0.000212589, No Iterations 4
time step continuity errors : sum local = 5.30225e-08, global = -1.99786e-09, cumulative = 3.7928e-06
GAMG: Solving for p, Initial residual = 0.00053523, Final residual = 7.96457e-07, No Iterations 21
time step continuity errors : sum local = 1.98614e-10, global = 2.31743e-11, cumulative = 3.79283e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00154066, Final residual = 3.47581e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00593352, Final residual = 9.86187e-06, No Iterations 6
ExecutionTime = 3.02 s ClockTime = 3 s
Time = 0.235
Courant Number mean: 0.0881928 max: 0.603257
smoothSolver: Solving for Ux, Initial residual = 0.00101618, Final residual = 4.08033e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00267144, Final residual = 4.95956e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00223024, Final residual = 0.000209155, No Iterations 4
time step continuity errors : sum local = 5.21599e-08, global = -1.79636e-09, cumulative = 3.79103e-06
GAMG: Solving for p, Initial residual = 0.000530552, Final residual = 7.74044e-07, No Iterations 21
time step continuity errors : sum local = 1.9301e-10, global = 2.23759e-11, cumulative = 3.79105e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0015391, Final residual = 3.40707e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00589338, Final residual = 9.58735e-06, No Iterations 6
ExecutionTime = 3.05 s ClockTime = 3 s
Time = 0.2375
Courant Number mean: 0.088258 max: 0.60339
smoothSolver: Solving for Ux, Initial residual = 0.00101513, Final residual = 3.99512e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00267136, Final residual = 4.86688e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00229828, Final residual = 0.000207889, No Iterations 4
time step continuity errors : sum local = 5.18373e-08, global = -1.74326e-09, cumulative = 3.78931e-06
GAMG: Solving for p, Initial residual = 0.000530602, Final residual = 7.61021e-07, No Iterations 21
time step continuity errors : sum local = 1.89724e-10, global = 2.21426e-11, cumulative = 3.78933e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00153685, Final residual = 3.3411e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00586326, Final residual = 9.32653e-06, No Iterations 6
ExecutionTime = 3.08 s ClockTime = 3 s
Time = 0.24
Courant Number mean: 0.0883245 max: 0.603527
smoothSolver: Solving for Ux, Initial residual = 0.00101473, Final residual = 3.91326e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00267084, Final residual = 4.77468e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00232998, Final residual = 0.000208161, No Iterations 4
time step continuity errors : sum local = 5.18947e-08, global = -1.64506e-09, cumulative = 3.78769e-06
GAMG: Solving for p, Initial residual = 0.000552859, Final residual = 7.54479e-07, No Iterations 21
time step continuity errors : sum local = 1.88061e-10, global = 2.19698e-11, cumulative = 3.78771e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00153476, Final residual = 3.27501e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00583862, Final residual = 9.08971e-06, No Iterations 6
ExecutionTime = 3.1 s ClockTime = 3 s
Time = 0.2425
Courant Number mean: 0.0883909 max: 0.603666
smoothSolver: Solving for Ux, Initial residual = 0.00101443, Final residual = 3.8357e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00266778, Final residual = 4.68349e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00235498, Final residual = 0.000215329, No Iterations 4
time step continuity errors : sum local = 5.36724e-08, global = -1.50053e-09, cumulative = 3.78621e-06
GAMG: Solving for p, Initial residual = 0.000546386, Final residual = 7.44861e-07, No Iterations 21
time step continuity errors : sum local = 1.85632e-10, global = 2.10044e-11, cumulative = 3.78623e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00153184, Final residual = 9.99373e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00581558, Final residual = 8.84761e-06, No Iterations 6
ExecutionTime = 3.13 s ClockTime = 3 s
Time = 0.245
Courant Number mean: 0.0884562 max: 0.603808
smoothSolver: Solving for Ux, Initial residual = 0.00101427, Final residual = 3.76449e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0026612, Final residual = 4.60474e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00231277, Final residual = 0.0002156, No Iterations 4
time step continuity errors : sum local = 5.37339e-08, global = -1.64738e-09, cumulative = 3.78458e-06
GAMG: Solving for p, Initial residual = 0.000534617, Final residual = 7.47735e-07, No Iterations 21
time step continuity errors : sum local = 1.86346e-10, global = 2.13237e-11, cumulative = 3.7846e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00152789, Final residual = 9.84661e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00579356, Final residual = 8.65385e-06, No Iterations 6
ExecutionTime = 3.15 s ClockTime = 3 s
Time = 0.2475
Courant Number mean: 0.0885204 max: 0.603952
smoothSolver: Solving for Ux, Initial residual = 0.00101398, Final residual = 3.69515e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.002652, Final residual = 4.52083e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00233114, Final residual = 0.000215526, No Iterations 4
time step continuity errors : sum local = 5.37177e-08, global = -1.64899e-09, cumulative = 3.78295e-06
GAMG: Solving for p, Initial residual = 0.000526374, Final residual = 7.37628e-07, No Iterations 21
time step continuity errors : sum local = 1.83846e-10, global = 2.10456e-11, cumulative = 3.78298e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00152351, Final residual = 9.70755e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00577367, Final residual = 8.46201e-06, No Iterations 6
ExecutionTime = 3.18 s ClockTime = 3 s
Time = 0.25
Courant Number mean: 0.088583 max: 0.604097
smoothSolver: Solving for Ux, Initial residual = 0.00101376, Final residual = 3.62663e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00264488, Final residual = 4.43865e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00230197, Final residual = 0.00021322, No Iterations 4
time step continuity errors : sum local = 5.3133e-08, global = -1.63604e-09, cumulative = 3.78134e-06
GAMG: Solving for p, Initial residual = 0.00052076, Final residual = 7.16907e-07, No Iterations 21
time step continuity errors : sum local = 1.78602e-10, global = 2.04562e-11, cumulative = 3.78136e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00151957, Final residual = 9.56318e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00575268, Final residual = 8.26065e-06, No Iterations 6
ExecutionTime = 3.2 s ClockTime = 3 s
Time = 0.2525
Courant Number mean: 0.088644 max: 0.604243
smoothSolver: Solving for Ux, Initial residual = 0.00101371, Final residual = 3.5596e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00264213, Final residual = 4.35538e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00220492, Final residual = 0.000214821, No Iterations 4
time step continuity errors : sum local = 5.35123e-08, global = -1.56653e-09, cumulative = 3.77979e-06
GAMG: Solving for p, Initial residual = 0.000514599, Final residual = 7.02883e-07, No Iterations 21
time step continuity errors : sum local = 1.75058e-10, global = 2.05913e-11, cumulative = 3.77981e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00151722, Final residual = 9.43432e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00573127, Final residual = 8.06135e-06, No Iterations 6
ExecutionTime = 3.23 s ClockTime = 3 s
Time = 0.255
Courant Number mean: 0.0887033 max: 0.60439
smoothSolver: Solving for Ux, Initial residual = 0.00101375, Final residual = 3.49455e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00264125, Final residual = 4.27319e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0022138, Final residual = 0.000218314, No Iterations 4
time step continuity errors : sum local = 5.43701e-08, global = -1.50084e-09, cumulative = 3.77831e-06
GAMG: Solving for p, Initial residual = 0.000511542, Final residual = 6.90777e-07, No Iterations 21
time step continuity errors : sum local = 1.72017e-10, global = 1.95352e-11, cumulative = 3.77833e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00151522, Final residual = 9.298e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00570645, Final residual = 7.86115e-06, No Iterations 6
ExecutionTime = 3.26 s ClockTime = 3 s
Time = 0.2575
Courant Number mean: 0.0887614 max: 0.604537
smoothSolver: Solving for Ux, Initial residual = 0.00101354, Final residual = 3.42974e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00263523, Final residual = 4.19656e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00214135, Final residual = 0.000130431, No Iterations 5
time step continuity errors : sum local = 3.24767e-08, global = 2.00329e-09, cumulative = 3.78034e-06
GAMG: Solving for p, Initial residual = 0.000463949, Final residual = 9.70205e-07, No Iterations 18
time step continuity errors : sum local = 2.41543e-10, global = 3.89485e-11, cumulative = 3.78038e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00151263, Final residual = 9.1553e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00567711, Final residual = 7.67034e-06, No Iterations 6
ExecutionTime = 3.28 s ClockTime = 3 s
Time = 0.26
Courant Number mean: 0.0888181 max: 0.604683
smoothSolver: Solving for Ux, Initial residual = 0.00101303, Final residual = 3.36554e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0026228, Final residual = 4.12501e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00213464, Final residual = 0.000125028, No Iterations 5
time step continuity errors : sum local = 3.11236e-08, global = 2.63576e-09, cumulative = 3.78301e-06
GAMG: Solving for p, Initial residual = 0.000460211, Final residual = 7.13985e-07, No Iterations 20
time step continuity errors : sum local = 1.77705e-10, global = 1.99292e-11, cumulative = 3.78303e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00151013, Final residual = 9.03586e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00564483, Final residual = 7.48548e-06, No Iterations 6
ExecutionTime = 3.31 s ClockTime = 3 s
Time = 0.2625
Courant Number mean: 0.0888736 max: 0.604828
smoothSolver: Solving for Ux, Initial residual = 0.00101221, Final residual = 3.30446e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00260607, Final residual = 4.05432e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00221986, Final residual = 0.000219655, No Iterations 4
time step continuity errors : sum local = 5.4656e-08, global = -3.05152e-09, cumulative = 3.77998e-06
GAMG: Solving for p, Initial residual = 0.000499178, Final residual = 6.78083e-07, No Iterations 21
time step continuity errors : sum local = 1.68672e-10, global = 1.7178e-11, cumulative = 3.78e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00150794, Final residual = 8.91521e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00562086, Final residual = 7.31063e-06, No Iterations 6
ExecutionTime = 3.33 s ClockTime = 3 s
Time = 0.265
Courant Number mean: 0.0889284 max: 0.604974
smoothSolver: Solving for Ux, Initial residual = 0.00101116, Final residual = 3.24238e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00259589, Final residual = 3.98369e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00210532, Final residual = 0.000121308, No Iterations 5
time step continuity errors : sum local = 3.01724e-08, global = 1.44094e-09, cumulative = 3.78144e-06
GAMG: Solving for p, Initial residual = 0.000442567, Final residual = 9.74844e-07, No Iterations 18
time step continuity errors : sum local = 2.42412e-10, global = 3.06253e-11, cumulative = 3.78147e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00150496, Final residual = 8.79011e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00559866, Final residual = 7.14414e-06, No Iterations 6
ExecutionTime = 3.35 s ClockTime = 3 s
Time = 0.2675
Courant Number mean: 0.0889826 max: 0.605123
smoothSolver: Solving for Ux, Initial residual = 0.00101012, Final residual = 3.18388e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00259383, Final residual = 3.91334e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00202308, Final residual = 0.000119117, No Iterations 5
time step continuity errors : sum local = 2.96184e-08, global = 2.23229e-09, cumulative = 3.7837e-06
GAMG: Solving for p, Initial residual = 0.000441329, Final residual = 9.60881e-07, No Iterations 18
time step continuity errors : sum local = 2.38878e-10, global = 3.83703e-11, cumulative = 3.78374e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00150096, Final residual = 8.66361e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00557651, Final residual = 6.98194e-06, No Iterations 6
ExecutionTime = 3.38 s ClockTime = 3 s
Time = 0.27
Courant Number mean: 0.0890362 max: 0.605271
smoothSolver: Solving for Ux, Initial residual = 0.00100968, Final residual = 3.12583e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00259158, Final residual = 3.84374e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00208292, Final residual = 0.000115924, No Iterations 5
time step continuity errors : sum local = 2.88168e-08, global = 2.38163e-09, cumulative = 3.78612e-06
GAMG: Solving for p, Initial residual = 0.000449773, Final residual = 9.57148e-07, No Iterations 18
time step continuity errors : sum local = 2.37878e-10, global = 3.67958e-11, cumulative = 3.78616e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149607, Final residual = 8.53269e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00555311, Final residual = 6.81699e-06, No Iterations 6
ExecutionTime = 3.41 s ClockTime = 3 s
Time = 0.2725
Courant Number mean: 0.0890897 max: 0.605417
smoothSolver: Solving for Ux, Initial residual = 0.00100945, Final residual = 3.07361e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00258681, Final residual = 3.77566e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00207335, Final residual = 0.000114406, No Iterations 5
time step continuity errors : sum local = 2.84319e-08, global = 2.27694e-09, cumulative = 3.78843e-06
GAMG: Solving for p, Initial residual = 0.000459644, Final residual = 9.07887e-07, No Iterations 18
time step continuity errors : sum local = 2.25587e-10, global = 3.71371e-11, cumulative = 3.78847e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149072, Final residual = 8.41222e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00553039, Final residual = 6.66748e-06, No Iterations 6
ExecutionTime = 3.43 s ClockTime = 3 s
Time = 0.275
Courant Number mean: 0.0891457 max: 0.605561
smoothSolver: Solving for Ux, Initial residual = 0.00100919, Final residual = 9.8886e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00257982, Final residual = 3.70688e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00214529, Final residual = 0.000211856, No Iterations 4
time step continuity errors : sum local = 5.26397e-08, global = -4.6101e-09, cumulative = 3.78386e-06
GAMG: Solving for p, Initial residual = 0.000599491, Final residual = 9.53587e-07, No Iterations 21
time step continuity errors : sum local = 2.3688e-10, global = 2.66118e-11, cumulative = 3.78389e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148641, Final residual = 8.29628e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0055101, Final residual = 6.51581e-06, No Iterations 6
ExecutionTime = 3.46 s ClockTime = 3 s
Time = 0.2775
Courant Number mean: 0.0892053 max: 0.605704
smoothSolver: Solving for Ux, Initial residual = 0.00100904, Final residual = 9.79087e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00257136, Final residual = 3.6416e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00215851, Final residual = 0.000211802, No Iterations 4
time step continuity errors : sum local = 5.26148e-08, global = 1.06198e-09, cumulative = 3.78495e-06
GAMG: Solving for p, Initial residual = 0.000585744, Final residual = 9.1744e-07, No Iterations 20
time step continuity errors : sum local = 2.27891e-10, global = 2.42834e-11, cumulative = 3.78497e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148364, Final residual = 8.1854e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00548949, Final residual = 6.36192e-06, No Iterations 6
ExecutionTime = 3.49 s ClockTime = 4 s
Time = 0.28
Courant Number mean: 0.0892655 max: 0.605845
smoothSolver: Solving for Ux, Initial residual = 0.00100904, Final residual = 9.66119e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00256512, Final residual = 3.56528e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00213501, Final residual = 0.000196906, No Iterations 4
time step continuity errors : sum local = 4.89039e-08, global = -2.63174e-09, cumulative = 3.78234e-06
GAMG: Solving for p, Initial residual = 0.000565167, Final residual = 8.82233e-07, No Iterations 21
time step continuity errors : sum local = 2.19065e-10, global = 2.54011e-11, cumulative = 3.78237e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148117, Final residual = 8.07563e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00546818, Final residual = 6.21092e-06, No Iterations 6
ExecutionTime = 3.51 s ClockTime = 4 s
Time = 0.2825
Courant Number mean: 0.0893255 max: 0.605983
smoothSolver: Solving for Ux, Initial residual = 0.00100931, Final residual = 9.55111e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00256442, Final residual = 3.50518e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0020789, Final residual = 0.000112579, No Iterations 5
time step continuity errors : sum local = 2.79521e-08, global = 1.41065e-09, cumulative = 3.78378e-06
GAMG: Solving for p, Initial residual = 0.000522052, Final residual = 9.90135e-07, No Iterations 19
time step continuity errors : sum local = 2.45797e-10, global = -4.46571e-11, cumulative = 3.78373e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147863, Final residual = 7.97207e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00544511, Final residual = 6.05803e-06, No Iterations 6
ExecutionTime = 3.53 s ClockTime = 4 s
Time = 0.285
Courant Number mean: 0.0893854 max: 0.606121
smoothSolver: Solving for Ux, Initial residual = 0.00100964, Final residual = 9.43729e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00256279, Final residual = 3.43941e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00205745, Final residual = 0.000204734, No Iterations 4
time step continuity errors : sum local = 5.08238e-08, global = -3.8265e-09, cumulative = 3.77991e-06
GAMG: Solving for p, Initial residual = 0.000547106, Final residual = 8.06568e-07, No Iterations 21
time step continuity errors : sum local = 2.00195e-10, global = 2.31757e-11, cumulative = 3.77993e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147547, Final residual = 7.86191e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0054206, Final residual = 5.91298e-06, No Iterations 6
ExecutionTime = 3.56 s ClockTime = 4 s
Time = 0.2875
Courant Number mean: 0.0894447 max: 0.606256
smoothSolver: Solving for Ux, Initial residual = 0.00100962, Final residual = 9.33196e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00255707, Final residual = 3.38127e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00193197, Final residual = 0.000106496, No Iterations 5
time step continuity errors : sum local = 2.64319e-08, global = 9.9171e-10, cumulative = 3.78092e-06
GAMG: Solving for p, Initial residual = 0.000489564, Final residual = 6.55259e-07, No Iterations 20
time step continuity errors : sum local = 1.62607e-10, global = 1.61534e-11, cumulative = 3.78094e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147281, Final residual = 7.74615e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00539912, Final residual = 5.77108e-06, No Iterations 6
ExecutionTime = 3.58 s ClockTime = 4 s
Time = 0.29
Courant Number mean: 0.0895036 max: 0.60639
smoothSolver: Solving for Ux, Initial residual = 0.00100932, Final residual = 9.22658e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00254577, Final residual = 3.32202e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00197044, Final residual = 0.000105153, No Iterations 5
time step continuity errors : sum local = 2.60905e-08, global = 2.3443e-09, cumulative = 3.78328e-06
GAMG: Solving for p, Initial residual = 0.000487316, Final residual = 9.97454e-07, No Iterations 19
time step continuity errors : sum local = 2.47436e-10, global = -4.38673e-11, cumulative = 3.78324e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146958, Final residual = 7.64164e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00537842, Final residual = 5.6366e-06, No Iterations 6
ExecutionTime = 3.61 s ClockTime = 4 s
Time = 0.2925
Courant Number mean: 0.0895621 max: 0.606521
smoothSolver: Solving for Ux, Initial residual = 0.00100885, Final residual = 9.11757e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00252987, Final residual = 9.96889e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00195844, Final residual = 0.000114412, No Iterations 5
time step continuity errors : sum local = 2.83812e-08, global = 2.86237e-09, cumulative = 3.7861e-06
GAMG: Solving for p, Initial residual = 0.000481241, Final residual = 8.34973e-07, No Iterations 20
time step continuity errors : sum local = 2.07101e-10, global = 3.01424e-11, cumulative = 3.78613e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146623, Final residual = 7.53669e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00535768, Final residual = 5.50054e-06, No Iterations 6
ExecutionTime = 3.64 s ClockTime = 4 s
Time = 0.295
Courant Number mean: 0.0896208 max: 0.606651
smoothSolver: Solving for Ux, Initial residual = 0.00100838, Final residual = 9.01565e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00251773, Final residual = 9.84571e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00191578, Final residual = 0.000105187, No Iterations 5
time step continuity errors : sum local = 2.60886e-08, global = 2.57414e-09, cumulative = 3.78871e-06
GAMG: Solving for p, Initial residual = 0.00046683, Final residual = 9.96431e-07, No Iterations 19
time step continuity errors : sum local = 2.47111e-10, global = -4.02887e-11, cumulative = 3.78867e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014625, Final residual = 7.42595e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00533709, Final residual = 5.36798e-06, No Iterations 6
ExecutionTime = 3.66 s ClockTime = 4 s
Time = 0.2975
Courant Number mean: 0.0896791 max: 0.606779
smoothSolver: Solving for Ux, Initial residual = 0.00100767, Final residual = 8.90699e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00251421, Final residual = 9.70821e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00185249, Final residual = 0.000110194, No Iterations 5
time step continuity errors : sum local = 2.73267e-08, global = 2.86405e-09, cumulative = 3.79153e-06
GAMG: Solving for p, Initial residual = 0.000464253, Final residual = 7.96583e-07, No Iterations 20
time step continuity errors : sum local = 1.97514e-10, global = 2.83084e-11, cumulative = 3.79156e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145796, Final residual = 7.31263e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00531599, Final residual = 5.23538e-06, No Iterations 6
ExecutionTime = 3.68 s ClockTime = 4 s
Time = 0.3
Courant Number mean: 0.0897375 max: 0.606906
smoothSolver: Solving for Ux, Initial residual = 0.00100726, Final residual = 8.80503e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00251142, Final residual = 9.57639e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00186377, Final residual = 0.000116602, No Iterations 5
time step continuity errors : sum local = 2.89096e-08, global = 2.81562e-09, cumulative = 3.79437e-06
GAMG: Solving for p, Initial residual = 0.000476631, Final residual = 6.9391e-07, No Iterations 19
time step continuity errors : sum local = 1.7201e-10, global = -1.48651e-11, cumulative = 3.79436e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145327, Final residual = 7.22606e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00529429, Final residual = 5.11266e-06, No Iterations 6
ExecutionTime = 3.73 s ClockTime = 4 s
Time = 0.3025
Courant Number mean: 0.0897958 max: 0.60703
smoothSolver: Solving for Ux, Initial residual = 0.0010072, Final residual = 8.69928e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00250701, Final residual = 9.44546e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00191393, Final residual = 0.000189233, No Iterations 4
time step continuity errors : sum local = 4.69058e-08, global = -3.29413e-09, cumulative = 3.79106e-06
GAMG: Solving for p, Initial residual = 0.000496065, Final residual = 7.63181e-07, No Iterations 21
time step continuity errors : sum local = 1.89128e-10, global = 2.22721e-11, cumulative = 3.79109e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145017, Final residual = 7.12903e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00527304, Final residual = 4.99075e-06, No Iterations 6
ExecutionTime = 3.76 s ClockTime = 4 s
Time = 0.305
Courant Number mean: 0.0898541 max: 0.607154
smoothSolver: Solving for Ux, Initial residual = 0.0010072, Final residual = 8.60221e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00250139, Final residual = 9.31991e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00193706, Final residual = 0.000184259, No Iterations 4
time step continuity errors : sum local = 4.56628e-08, global = 5.68917e-10, cumulative = 3.79166e-06
GAMG: Solving for p, Initial residual = 0.000500575, Final residual = 9.98892e-07, No Iterations 18
time step continuity errors : sum local = 2.47525e-10, global = 2.0641e-11, cumulative = 3.79168e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144692, Final residual = 7.03039e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00525158, Final residual = 4.86667e-06, No Iterations 6
ExecutionTime = 3.78 s ClockTime = 4 s
Time = 0.3075
Courant Number mean: 0.0899128 max: 0.607277
smoothSolver: Solving for Ux, Initial residual = 0.00100729, Final residual = 8.50916e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00249466, Final residual = 9.18821e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00191952, Final residual = 0.000183887, No Iterations 4
time step continuity errors : sum local = 4.55651e-08, global = -1.4608e-09, cumulative = 3.79022e-06
GAMG: Solving for p, Initial residual = 0.000494025, Final residual = 9.5415e-07, No Iterations 19
time step continuity errors : sum local = 2.36407e-10, global = 3.41407e-11, cumulative = 3.79025e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144435, Final residual = 6.93108e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00523028, Final residual = 4.74345e-06, No Iterations 6
ExecutionTime = 3.81 s ClockTime = 4 s
Time = 0.31
Courant Number mean: 0.0899718 max: 0.607398
smoothSolver: Solving for Ux, Initial residual = 0.00100748, Final residual = 8.41244e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00248899, Final residual = 9.07038e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00186071, Final residual = 0.000184297, No Iterations 4
time step continuity errors : sum local = 4.56642e-08, global = -1.22469e-09, cumulative = 3.78902e-06
GAMG: Solving for p, Initial residual = 0.000486407, Final residual = 9.26301e-07, No Iterations 19
time step continuity errors : sum local = 2.29496e-10, global = 2.19285e-11, cumulative = 3.78905e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144122, Final residual = 6.83141e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00520982, Final residual = 4.62188e-06, No Iterations 6
ExecutionTime = 3.83 s ClockTime = 4 s
Time = 0.3125
Courant Number mean: 0.0900313 max: 0.607518
smoothSolver: Solving for Ux, Initial residual = 0.00100755, Final residual = 8.32872e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00248776, Final residual = 8.94389e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00194293, Final residual = 0.000180435, No Iterations 4
time step continuity errors : sum local = 4.47051e-08, global = -4.5931e-10, cumulative = 3.78859e-06
GAMG: Solving for p, Initial residual = 0.000480417, Final residual = 8.01235e-07, No Iterations 19
time step continuity errors : sum local = 1.98516e-10, global = 2.18074e-11, cumulative = 3.78861e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143757, Final residual = 6.74734e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0051925, Final residual = 9.98569e-06, No Iterations 5
ExecutionTime = 3.86 s ClockTime = 4 s
Time = 0.315
Courant Number mean: 0.0900919 max: 0.607637
smoothSolver: Solving for Ux, Initial residual = 0.00100764, Final residual = 8.23956e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00248512, Final residual = 8.81597e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00196612, Final residual = 0.0001842, No Iterations 4
time step continuity errors : sum local = 4.56366e-08, global = -1.17469e-09, cumulative = 3.78743e-06
GAMG: Solving for p, Initial residual = 0.000490346, Final residual = 9.21454e-07, No Iterations 19
time step continuity errors : sum local = 2.28272e-10, global = 2.37811e-11, cumulative = 3.78746e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143359, Final residual = 6.66458e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00517511, Final residual = 9.76786e-06, No Iterations 5
ExecutionTime = 3.88 s ClockTime = 4 s
Time = 0.3175
Courant Number mean: 0.0901531 max: 0.607755
smoothSolver: Solving for Ux, Initial residual = 0.00100749, Final residual = 8.15712e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00247912, Final residual = 8.693e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00177522, Final residual = 0.00017711, No Iterations 4
time step continuity errors : sum local = 4.38709e-08, global = -4.40755e-10, cumulative = 3.78702e-06
GAMG: Solving for p, Initial residual = 0.00046078, Final residual = 7.55964e-07, No Iterations 19
time step continuity errors : sum local = 1.87231e-10, global = 1.80898e-11, cumulative = 3.78704e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142964, Final residual = 6.5669e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00515678, Final residual = 9.55181e-06, No Iterations 5
ExecutionTime = 3.9 s ClockTime = 4 s
Time = 0.32
Courant Number mean: 0.0902152 max: 0.607871
smoothSolver: Solving for Ux, Initial residual = 0.00100733, Final residual = 8.07219e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00246908, Final residual = 8.5713e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00176348, Final residual = 0.000175565, No Iterations 4
time step continuity errors : sum local = 4.34751e-08, global = -8.89011e-10, cumulative = 3.78615e-06
GAMG: Solving for p, Initial residual = 0.000457929, Final residual = 8.5306e-07, No Iterations 19
time step continuity errors : sum local = 2.11204e-10, global = 2.14441e-11, cumulative = 3.78617e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142554, Final residual = 6.46813e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00513825, Final residual = 9.33143e-06, No Iterations 5
ExecutionTime = 3.93 s ClockTime = 4 s
Time = 0.3225
Courant Number mean: 0.0902781 max: 0.607985
smoothSolver: Solving for Ux, Initial residual = 0.00100698, Final residual = 7.98783e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00245469, Final residual = 8.46102e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00166761, Final residual = 0.000109708, No Iterations 5
time step continuity errors : sum local = 2.71589e-08, global = 1.07853e-09, cumulative = 3.78725e-06
GAMG: Solving for p, Initial residual = 0.000431456, Final residual = 9.16972e-07, No Iterations 18
time step continuity errors : sum local = 2.2698e-10, global = 1.89594e-11, cumulative = 3.78727e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142122, Final residual = 6.36559e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00511856, Final residual = 9.12539e-06, No Iterations 5
ExecutionTime = 3.95 s ClockTime = 4 s
Time = 0.325
Courant Number mean: 0.0903412 max: 0.608099
smoothSolver: Solving for Ux, Initial residual = 0.00100647, Final residual = 7.90314e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00243821, Final residual = 8.35113e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0017148, Final residual = 0.00017091, No Iterations 4
time step continuity errors : sum local = 4.23045e-08, global = -1.54926e-09, cumulative = 3.78572e-06
GAMG: Solving for p, Initial residual = 0.000453219, Final residual = 9.2538e-07, No Iterations 19
time step continuity errors : sum local = 2.29047e-10, global = 2.55077e-11, cumulative = 3.78574e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141665, Final residual = 6.27774e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00509796, Final residual = 8.90357e-06, No Iterations 5
ExecutionTime = 3.97 s ClockTime = 4 s
Time = 0.3275
Courant Number mean: 0.0904047 max: 0.608211
smoothSolver: Solving for Ux, Initial residual = 0.00100577, Final residual = 7.81925e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0024305, Final residual = 8.24294e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00167427, Final residual = 0.00016064, No Iterations 4
time step continuity errors : sum local = 3.97596e-08, global = 4.59951e-10, cumulative = 3.7862e-06
GAMG: Solving for p, Initial residual = 0.000444231, Final residual = 7.92939e-07, No Iterations 18
time step continuity errors : sum local = 1.96251e-10, global = 1.27549e-11, cumulative = 3.78621e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014133, Final residual = 6.19742e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00507691, Final residual = 8.69857e-06, No Iterations 5
ExecutionTime = 4 s ClockTime = 4 s
Time = 0.33
Courant Number mean: 0.0904686 max: 0.608322
smoothSolver: Solving for Ux, Initial residual = 0.00100505, Final residual = 7.73987e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00242624, Final residual = 8.13205e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00165305, Final residual = 0.00016002, No Iterations 4
time step continuity errors : sum local = 3.96022e-08, global = -2.0303e-10, cumulative = 3.78601e-06
GAMG: Solving for p, Initial residual = 0.000441104, Final residual = 9.48937e-07, No Iterations 17
time step continuity errors : sum local = 2.34844e-10, global = 1.8377e-11, cumulative = 3.78603e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141012, Final residual = 6.11596e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00505613, Final residual = 8.52035e-06, No Iterations 5
ExecutionTime = 4.02 s ClockTime = 4 s
Time = 0.3325
Courant Number mean: 0.090533 max: 0.608432
smoothSolver: Solving for Ux, Initial residual = 0.00100479, Final residual = 7.65497e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00242211, Final residual = 8.02779e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00165982, Final residual = 0.000163105, No Iterations 4
time step continuity errors : sum local = 4.03641e-08, global = -8.01839e-10, cumulative = 3.78523e-06
GAMG: Solving for p, Initial residual = 0.000442001, Final residual = 7.39904e-07, No Iterations 19
time step continuity errors : sum local = 1.83091e-10, global = 1.51068e-11, cumulative = 3.78524e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140741, Final residual = 6.03221e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00503598, Final residual = 8.33307e-06, No Iterations 5
ExecutionTime = 4.04 s ClockTime = 4 s
Time = 0.335
Courant Number mean: 0.0905976 max: 0.60854
smoothSolver: Solving for Ux, Initial residual = 0.00100497, Final residual = 7.57534e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241743, Final residual = 7.92224e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00168915, Final residual = 0.000157323, No Iterations 4
time step continuity errors : sum local = 3.89294e-08, global = 6.03269e-10, cumulative = 3.78585e-06
GAMG: Solving for p, Initial residual = 0.000445126, Final residual = 7.60827e-07, No Iterations 18
time step continuity errors : sum local = 1.88262e-10, global = 1.11202e-11, cumulative = 3.78586e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140469, Final residual = 5.95246e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00501586, Final residual = 8.13775e-06, No Iterations 5
ExecutionTime = 4.07 s ClockTime = 4 s
Time = 0.3375
Courant Number mean: 0.0906624 max: 0.608647
smoothSolver: Solving for Ux, Initial residual = 0.00100527, Final residual = 7.50044e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241214, Final residual = 7.81557e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00177521, Final residual = 0.000159535, No Iterations 4
time step continuity errors : sum local = 3.94702e-08, global = -4.90829e-11, cumulative = 3.78581e-06
GAMG: Solving for p, Initial residual = 0.000462766, Final residual = 9.72362e-07, No Iterations 15
time step continuity errors : sum local = 2.40547e-10, global = 1.22494e-11, cumulative = 3.78582e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140166, Final residual = 5.8646e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00499832, Final residual = 7.95702e-06, No Iterations 5
ExecutionTime = 4.09 s ClockTime = 4 s
Time = 0.34
Courant Number mean: 0.0907276 max: 0.608752
smoothSolver: Solving for Ux, Initial residual = 0.00100572, Final residual = 7.42724e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240749, Final residual = 7.71712e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00172697, Final residual = 0.000157343, No Iterations 4
time step continuity errors : sum local = 3.89206e-08, global = 2.68179e-10, cumulative = 3.78609e-06
GAMG: Solving for p, Initial residual = 0.000454474, Final residual = 6.13267e-07, No Iterations 18
time step continuity errors : sum local = 1.51685e-10, global = 8.02055e-12, cumulative = 3.7861e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139808, Final residual = 5.77785e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00498237, Final residual = 7.78812e-06, No Iterations 5
ExecutionTime = 4.11 s ClockTime = 4 s
Time = 0.3425
Courant Number mean: 0.0907929 max: 0.608856
smoothSolver: Solving for Ux, Initial residual = 0.00100606, Final residual = 7.35935e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240578, Final residual = 7.61772e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00172806, Final residual = 0.000158696, No Iterations 4
time step continuity errors : sum local = 3.92472e-08, global = 5.34296e-10, cumulative = 3.78663e-06
GAMG: Solving for p, Initial residual = 0.000451345, Final residual = 7.36458e-07, No Iterations 18
time step continuity errors : sum local = 1.82123e-10, global = 1.09813e-11, cumulative = 3.78664e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139448, Final residual = 5.70373e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00496742, Final residual = 7.6183e-06, No Iterations 5
ExecutionTime = 4.14 s ClockTime = 4 s
Time = 0.345
Courant Number mean: 0.0908585 max: 0.608959
smoothSolver: Solving for Ux, Initial residual = 0.00100624, Final residual = 7.29045e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240398, Final residual = 7.51987e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00173458, Final residual = 0.000157541, No Iterations 4
time step continuity errors : sum local = 3.89573e-08, global = 1.7496e-10, cumulative = 3.78682e-06
GAMG: Solving for p, Initial residual = 0.000444832, Final residual = 9.53244e-07, No Iterations 16
time step continuity errors : sum local = 2.35716e-10, global = 1.19728e-11, cumulative = 3.78683e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139085, Final residual = 5.63175e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00495181, Final residual = 7.4529e-06, No Iterations 5
ExecutionTime = 4.16 s ClockTime = 4 s
Time = 0.3475
Courant Number mean: 0.090924 max: 0.60906
smoothSolver: Solving for Ux, Initial residual = 0.00100627, Final residual = 7.22374e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239931, Final residual = 7.42201e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00172289, Final residual = 0.000161533, No Iterations 4
time step continuity errors : sum local = 3.99375e-08, global = 9.82903e-10, cumulative = 3.78781e-06
GAMG: Solving for p, Initial residual = 0.000436023, Final residual = 6.91586e-07, No Iterations 18
time step continuity errors : sum local = 1.70971e-10, global = 8.96238e-12, cumulative = 3.78782e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00138657, Final residual = 5.55637e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00493484, Final residual = 7.28808e-06, No Iterations 5
ExecutionTime = 4.18 s ClockTime = 4 s
Time = 0.35
Courant Number mean: 0.0909899 max: 0.609159
smoothSolver: Solving for Ux, Initial residual = 0.00100605, Final residual = 7.15387e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239073, Final residual = 7.32851e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00162893, Final residual = 0.000160921, No Iterations 4
time step continuity errors : sum local = 3.97788e-08, global = 2.86588e-10, cumulative = 3.78811e-06
GAMG: Solving for p, Initial residual = 0.000426426, Final residual = 9.95387e-07, No Iterations 16
time step continuity errors : sum local = 2.4605e-10, global = 1.27906e-11, cumulative = 3.78812e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013817, Final residual = 5.47075e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00491665, Final residual = 7.12336e-06, No Iterations 5
ExecutionTime = 4.2 s ClockTime = 4 s
Time = 0.3525
Courant Number mean: 0.0910559 max: 0.609257
smoothSolver: Solving for Ux, Initial residual = 0.00100579, Final residual = 7.08498e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237859, Final residual = 7.23959e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00161132, Final residual = 9.19991e-05, No Iterations 5
time step continuity errors : sum local = 2.27392e-08, global = -8.05143e-10, cumulative = 3.78731e-06
GAMG: Solving for p, Initial residual = 0.000393691, Final residual = 9.28174e-07, No Iterations 17
time step continuity errors : sum local = 2.29403e-10, global = 1.32493e-11, cumulative = 3.78733e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00137687, Final residual = 5.40005e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00489758, Final residual = 6.95618e-06, No Iterations 5
ExecutionTime = 4.23 s ClockTime = 4 s
Time = 0.355
Courant Number mean: 0.0911219 max: 0.609352
smoothSolver: Solving for Ux, Initial residual = 0.00100562, Final residual = 7.01536e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00236258, Final residual = 7.1522e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00159229, Final residual = 9.17992e-05, No Iterations 5
time step continuity errors : sum local = 2.26875e-08, global = -1.26009e-09, cumulative = 3.78607e-06
GAMG: Solving for p, Initial residual = 0.000395461, Final residual = 9.39544e-07, No Iterations 17
time step continuity errors : sum local = 2.32192e-10, global = 1.1925e-11, cumulative = 3.78608e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00137291, Final residual = 5.32379e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00487742, Final residual = 6.79165e-06, No Iterations 5
ExecutionTime = 4.25 s ClockTime = 4 s
Time = 0.3575
Courant Number mean: 0.0911878 max: 0.609446
smoothSolver: Solving for Ux, Initial residual = 0.00100536, Final residual = 6.94754e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234919, Final residual = 7.06311e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00157753, Final residual = 9.09853e-05, No Iterations 5
time step continuity errors : sum local = 2.24833e-08, global = -1.5262e-09, cumulative = 3.78455e-06
GAMG: Solving for p, Initial residual = 0.000390819, Final residual = 9.38557e-07, No Iterations 17
time step continuity errors : sum local = 2.31912e-10, global = 1.20777e-11, cumulative = 3.78457e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136925, Final residual = 5.25204e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00485641, Final residual = 6.63994e-06, No Iterations 5
ExecutionTime = 4.27 s ClockTime = 4 s
Time = 0.36
Courant Number mean: 0.0912539 max: 0.609538
smoothSolver: Solving for Ux, Initial residual = 0.00100496, Final residual = 6.87959e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234237, Final residual = 6.97414e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00156798, Final residual = 9.22934e-05, No Iterations 5
time step continuity errors : sum local = 2.28047e-08, global = -1.55112e-09, cumulative = 3.78301e-06
GAMG: Solving for p, Initial residual = 0.000389493, Final residual = 8.99773e-07, No Iterations 17
time step continuity errors : sum local = 2.22319e-10, global = 1.09042e-11, cumulative = 3.78303e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013654, Final residual = 5.18505e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00483648, Final residual = 6.50494e-06, No Iterations 5
ExecutionTime = 4.3 s ClockTime = 4 s
Time = 0.3625
Courant Number mean: 0.09132 max: 0.609628
smoothSolver: Solving for Ux, Initial residual = 0.00100444, Final residual = 6.8133e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00233807, Final residual = 6.88708e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00162598, Final residual = 9.33692e-05, No Iterations 5
time step continuity errors : sum local = 2.30693e-08, global = -1.6838e-09, cumulative = 3.78134e-06
GAMG: Solving for p, Initial residual = 0.000395965, Final residual = 8.81016e-07, No Iterations 17
time step continuity errors : sum local = 2.17668e-10, global = 1.06654e-11, cumulative = 3.78135e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136138, Final residual = 5.11301e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00481889, Final residual = 6.36363e-06, No Iterations 5
ExecutionTime = 4.32 s ClockTime = 4 s
Time = 0.365
Courant Number mean: 0.091386 max: 0.609716
smoothSolver: Solving for Ux, Initial residual = 0.00100401, Final residual = 6.74696e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00233418, Final residual = 6.79922e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00163537, Final residual = 9.88728e-05, No Iterations 5
time step continuity errors : sum local = 2.44267e-08, global = -1.43509e-09, cumulative = 3.77992e-06
GAMG: Solving for p, Initial residual = 0.000398817, Final residual = 9.01411e-07, No Iterations 17
time step continuity errors : sum local = 2.22681e-10, global = 1.14629e-11, cumulative = 3.77993e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00135696, Final residual = 5.04367e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00480313, Final residual = 6.22228e-06, No Iterations 5
ExecutionTime = 4.35 s ClockTime = 4 s
Time = 0.3675
Courant Number mean: 0.0914524 max: 0.609803
smoothSolver: Solving for Ux, Initial residual = 0.00100415, Final residual = 6.68566e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00233031, Final residual = 6.71314e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00155803, Final residual = 9.06449e-05, No Iterations 5
time step continuity errors : sum local = 2.2391e-08, global = -1.51067e-09, cumulative = 3.77842e-06
GAMG: Solving for p, Initial residual = 0.000389838, Final residual = 8.68767e-07, No Iterations 17
time step continuity errors : sum local = 2.14585e-10, global = 1.03772e-11, cumulative = 3.77843e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00135267, Final residual = 4.9727e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00478884, Final residual = 6.09565e-06, No Iterations 5
ExecutionTime = 4.38 s ClockTime = 4 s
Time = 0.37
Courant Number mean: 0.0915186 max: 0.609889
smoothSolver: Solving for Ux, Initial residual = 0.00100434, Final residual = 6.62725e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00232638, Final residual = 6.62813e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00165066, Final residual = 9.3164e-05, No Iterations 5
time step continuity errors : sum local = 2.30086e-08, global = -1.57314e-09, cumulative = 3.77686e-06
GAMG: Solving for p, Initial residual = 0.000396711, Final residual = 8.48494e-07, No Iterations 17
time step continuity errors : sum local = 2.09523e-10, global = 9.89327e-12, cumulative = 3.77687e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00134855, Final residual = 4.90498e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0047754, Final residual = 5.96917e-06, No Iterations 5
ExecutionTime = 4.4 s ClockTime = 4 s
Time = 0.3725
Courant Number mean: 0.0915848 max: 0.609972
smoothSolver: Solving for Ux, Initial residual = 0.00100471, Final residual = 6.57155e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023244, Final residual = 6.54535e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00165992, Final residual = 9.33835e-05, No Iterations 5
time step continuity errors : sum local = 2.3058e-08, global = -1.5725e-09, cumulative = 3.77529e-06
GAMG: Solving for p, Initial residual = 0.000402211, Final residual = 8.16228e-07, No Iterations 17
time step continuity errors : sum local = 2.0152e-10, global = 9.10278e-12, cumulative = 3.7753e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00134449, Final residual = 4.84172e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00476124, Final residual = 5.84262e-06, No Iterations 5
ExecutionTime = 4.43 s ClockTime = 4 s
Time = 0.375
Courant Number mean: 0.0916507 max: 0.610054
smoothSolver: Solving for Ux, Initial residual = 0.00100495, Final residual = 6.5167e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00232319, Final residual = 6.46309e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00168774, Final residual = 9.33713e-05, No Iterations 5
time step continuity errors : sum local = 2.30491e-08, global = -1.60654e-09, cumulative = 3.7737e-06
GAMG: Solving for p, Initial residual = 0.000397705, Final residual = 8.13115e-07, No Iterations 17
time step continuity errors : sum local = 2.00689e-10, global = 9.09655e-12, cumulative = 3.7737e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00134034, Final residual = 4.77889e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00474557, Final residual = 5.72237e-06, No Iterations 5
ExecutionTime = 4.46 s ClockTime = 5 s
Time = 0.3775
Courant Number mean: 0.0917164 max: 0.610135
smoothSolver: Solving for Ux, Initial residual = 0.00100505, Final residual = 6.4609e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023191, Final residual = 6.38136e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00157236, Final residual = 9.37053e-05, No Iterations 5
time step continuity errors : sum local = 2.31258e-08, global = -1.61495e-09, cumulative = 3.77209e-06
GAMG: Solving for p, Initial residual = 0.000384859, Final residual = 7.89934e-07, No Iterations 17
time step continuity errors : sum local = 1.94933e-10, global = 8.54242e-12, cumulative = 3.7721e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00133601, Final residual = 4.71985e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00472856, Final residual = 5.59834e-06, No Iterations 5
ExecutionTime = 4.49 s ClockTime = 5 s
Time = 0.38
Courant Number mean: 0.0917817 max: 0.610214
smoothSolver: Solving for Ux, Initial residual = 0.00100499, Final residual = 6.40466e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231223, Final residual = 6.30533e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00160589, Final residual = 9.26839e-05, No Iterations 5
time step continuity errors : sum local = 2.28698e-08, global = -1.64562e-09, cumulative = 3.77045e-06
GAMG: Solving for p, Initial residual = 0.00038536, Final residual = 7.79089e-07, No Iterations 17
time step continuity errors : sum local = 1.92224e-10, global = 8.35631e-12, cumulative = 3.77046e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00133193, Final residual = 4.65407e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0047112, Final residual = 5.47834e-06, No Iterations 5
ExecutionTime = 4.51 s ClockTime = 5 s
Time = 0.3825
Courant Number mean: 0.0918465 max: 0.610292
smoothSolver: Solving for Ux, Initial residual = 0.00100484, Final residual = 6.34828e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00230209, Final residual = 6.23198e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00169694, Final residual = 9.3377e-05, No Iterations 5
time step continuity errors : sum local = 2.30367e-08, global = -1.65978e-09, cumulative = 3.7688e-06
GAMG: Solving for p, Initial residual = 0.000378969, Final residual = 7.52266e-07, No Iterations 17
time step continuity errors : sum local = 1.85574e-10, global = 8.01964e-12, cumulative = 3.76881e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00132831, Final residual = 4.596e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00469325, Final residual = 5.35435e-06, No Iterations 5
ExecutionTime = 4.54 s ClockTime = 5 s
Time = 0.385
Courant Number mean: 0.091911 max: 0.610368
smoothSolver: Solving for Ux, Initial residual = 0.00100459, Final residual = 6.29137e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00228936, Final residual = 6.15892e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00156313, Final residual = 9.72816e-05, No Iterations 5
time step continuity errors : sum local = 2.39953e-08, global = -1.74028e-09, cumulative = 3.76707e-06
GAMG: Solving for p, Initial residual = 0.000378958, Final residual = 7.55452e-07, No Iterations 17
time step continuity errors : sum local = 1.86317e-10, global = 7.87897e-12, cumulative = 3.76708e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00132461, Final residual = 4.54384e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0046743, Final residual = 5.23677e-06, No Iterations 5
ExecutionTime = 4.56 s ClockTime = 5 s
Time = 0.3875
Courant Number mean: 0.0919747 max: 0.610444
smoothSolver: Solving for Ux, Initial residual = 0.00100439, Final residual = 6.23439e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00227389, Final residual = 6.08604e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00153708, Final residual = 9.41077e-05, No Iterations 5
time step continuity errors : sum local = 2.32075e-08, global = -1.71331e-09, cumulative = 3.76536e-06
GAMG: Solving for p, Initial residual = 0.000364576, Final residual = 7.24888e-07, No Iterations 17
time step continuity errors : sum local = 1.78743e-10, global = 7.31973e-12, cumulative = 3.76537e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00132084, Final residual = 4.48507e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00465452, Final residual = 5.12717e-06, No Iterations 5
ExecutionTime = 4.59 s ClockTime = 5 s
Time = 0.39
Courant Number mean: 0.0920378 max: 0.610518
smoothSolver: Solving for Ux, Initial residual = 0.00100416, Final residual = 6.1786e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00226125, Final residual = 6.01232e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00150448, Final residual = 9.4156e-05, No Iterations 5
time step continuity errors : sum local = 2.32149e-08, global = -1.78026e-09, cumulative = 3.76359e-06
GAMG: Solving for p, Initial residual = 0.000360206, Final residual = 7.20824e-07, No Iterations 17
time step continuity errors : sum local = 1.77711e-10, global = 7.37857e-12, cumulative = 3.7636e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00131701, Final residual = 4.42872e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00463739, Final residual = 5.02395e-06, No Iterations 5
ExecutionTime = 4.61 s ClockTime = 5 s
Time = 0.3925
Courant Number mean: 0.0921002 max: 0.610591
smoothSolver: Solving for Ux, Initial residual = 0.00100403, Final residual = 6.12353e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.002253, Final residual = 5.93972e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00160873, Final residual = 8.97138e-05, No Iterations 5
time step continuity errors : sum local = 2.21177e-08, global = -1.71071e-09, cumulative = 3.76189e-06
GAMG: Solving for p, Initial residual = 0.000364789, Final residual = 6.88883e-07, No Iterations 17
time step continuity errors : sum local = 1.69834e-10, global = 6.70556e-12, cumulative = 3.76189e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00131302, Final residual = 4.36709e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00462298, Final residual = 4.92111e-06, No Iterations 5
ExecutionTime = 4.63 s ClockTime = 5 s
Time = 0.395
Courant Number mean: 0.0921618 max: 0.610663
smoothSolver: Solving for Ux, Initial residual = 0.00100389, Final residual = 6.06877e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0022489, Final residual = 5.86667e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00162406, Final residual = 0.000100299, No Iterations 5
time step continuity errors : sum local = 2.47282e-08, global = -1.95911e-09, cumulative = 3.75993e-06
GAMG: Solving for p, Initial residual = 0.00038065, Final residual = 7.15323e-07, No Iterations 17
time step continuity errors : sum local = 1.76369e-10, global = 7.14108e-12, cumulative = 3.75994e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00130916, Final residual = 4.30629e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0046094, Final residual = 4.82555e-06, No Iterations 5
ExecutionTime = 4.66 s ClockTime = 5 s
Time = 0.3975
Courant Number mean: 0.0922226 max: 0.610735
smoothSolver: Solving for Ux, Initial residual = 0.00100401, Final residual = 6.01748e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00224595, Final residual = 5.79695e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00150027, Final residual = 9.37825e-05, No Iterations 5
time step continuity errors : sum local = 2.31222e-08, global = -1.89511e-09, cumulative = 3.75805e-06
GAMG: Solving for p, Initial residual = 0.000357458, Final residual = 6.62874e-07, No Iterations 17
time step continuity errors : sum local = 1.63427e-10, global = 6.16457e-12, cumulative = 3.75805e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00130455, Final residual = 4.24942e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00459675, Final residual = 4.73901e-06, No Iterations 5
ExecutionTime = 4.68 s ClockTime = 5 s
Time = 0.4
Courant Number mean: 0.0922827 max: 0.610806
smoothSolver: Solving for Ux, Initial residual = 0.00100407, Final residual = 5.96928e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.002243, Final residual = 5.72557e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00145638, Final residual = 9.27582e-05, No Iterations 5
time step continuity errors : sum local = 2.28675e-08, global = -1.94476e-09, cumulative = 3.75611e-06
GAMG: Solving for p, Initial residual = 0.00035372, Final residual = 6.68158e-07, No Iterations 17
time step continuity errors : sum local = 1.6471e-10, global = 6.38679e-12, cumulative = 3.75611e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00129976, Final residual = 4.19874e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00458468, Final residual = 4.64833e-06, No Iterations 5
ExecutionTime = 4.73 s ClockTime = 5 s
Time = 0.4025
Courant Number mean: 0.0923443 max: 0.610876
smoothSolver: Solving for Ux, Initial residual = 0.0010042, Final residual = 5.92331e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00224147, Final residual = 5.65546e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00148994, Final residual = 9.27403e-05, No Iterations 5
time step continuity errors : sum local = 2.28615e-08, global = -1.96073e-09, cumulative = 3.75415e-06
GAMG: Solving for p, Initial residual = 0.000357163, Final residual = 6.49994e-07, No Iterations 17
time step continuity errors : sum local = 1.60224e-10, global = 5.91973e-12, cumulative = 3.75416e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00129509, Final residual = 4.14924e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00457137, Final residual = 4.56141e-06, No Iterations 5
ExecutionTime = 4.76 s ClockTime = 5 s
Time = 0.405
Courant Number mean: 0.0924073 max: 0.610946
smoothSolver: Solving for Ux, Initial residual = 0.00100434, Final residual = 5.87702e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00224107, Final residual = 5.58682e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00158897, Final residual = 9.20295e-05, No Iterations 5
time step continuity errors : sum local = 2.26841e-08, global = -1.99877e-09, cumulative = 3.75216e-06
GAMG: Solving for p, Initial residual = 0.000369766, Final residual = 6.50964e-07, No Iterations 17
time step continuity errors : sum local = 1.60448e-10, global = 5.99115e-12, cumulative = 3.75217e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00129062, Final residual = 4.10206e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00455649, Final residual = 4.47068e-06, No Iterations 5
ExecutionTime = 4.78 s ClockTime = 5 s
Time = 0.4075
Courant Number mean: 0.0924711 max: 0.611015
smoothSolver: Solving for Ux, Initial residual = 0.00100447, Final residual = 5.83065e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00223915, Final residual = 5.51829e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00157282, Final residual = 9.27314e-05, No Iterations 5
time step continuity errors : sum local = 2.28553e-08, global = -2.05504e-09, cumulative = 3.75011e-06
GAMG: Solving for p, Initial residual = 0.000365564, Final residual = 6.40821e-07, No Iterations 17
time step continuity errors : sum local = 1.57936e-10, global = 5.74963e-12, cumulative = 3.75012e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128701, Final residual = 4.05253e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00454073, Final residual = 4.38317e-06, No Iterations 5
ExecutionTime = 4.81 s ClockTime = 5 s
Time = 0.41
Courant Number mean: 0.0925356 max: 0.611084
smoothSolver: Solving for Ux, Initial residual = 0.00100456, Final residual = 5.78436e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00223443, Final residual = 5.45435e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00158291, Final residual = 9.2491e-05, No Iterations 5
time step continuity errors : sum local = 2.27953e-08, global = -2.09863e-09, cumulative = 3.74802e-06
GAMG: Solving for p, Initial residual = 0.000361398, Final residual = 6.44166e-07, No Iterations 17
time step continuity errors : sum local = 1.58763e-10, global = 5.8144e-12, cumulative = 3.74802e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128395, Final residual = 4.00131e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00452367, Final residual = 4.29631e-06, No Iterations 5
ExecutionTime = 4.84 s ClockTime = 5 s
Time = 0.4125
Courant Number mean: 0.0926004 max: 0.611152
smoothSolver: Solving for Ux, Initial residual = 0.0010046, Final residual = 5.73857e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00222667, Final residual = 5.39137e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00160635, Final residual = 9.19485e-05, No Iterations 5
time step continuity errors : sum local = 2.2662e-08, global = -2.12702e-09, cumulative = 3.7459e-06
GAMG: Solving for p, Initial residual = 0.000357232, Final residual = 6.44576e-07, No Iterations 17
time step continuity errors : sum local = 1.58864e-10, global = 5.77864e-12, cumulative = 3.7459e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128117, Final residual = 3.96271e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00450584, Final residual = 4.21266e-06, No Iterations 5
ExecutionTime = 4.87 s ClockTime = 5 s
Time = 0.415
Courant Number mean: 0.0926654 max: 0.61122
smoothSolver: Solving for Ux, Initial residual = 0.00100445, Final residual = 5.69189e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00221702, Final residual = 5.32961e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00166391, Final residual = 9.25352e-05, No Iterations 5
time step continuity errors : sum local = 2.28062e-08, global = -2.19256e-09, cumulative = 3.74371e-06
GAMG: Solving for p, Initial residual = 0.000350456, Final residual = 6.52327e-07, No Iterations 17
time step continuity errors : sum local = 1.6077e-10, global = 5.88904e-12, cumulative = 3.74372e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00127863, Final residual = 3.91959e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00448742, Final residual = 4.1296e-06, No Iterations 5
ExecutionTime = 4.89 s ClockTime = 5 s
Time = 0.4175
Courant Number mean: 0.0927305 max: 0.611288
smoothSolver: Solving for Ux, Initial residual = 0.00100431, Final residual = 5.64573e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00220495, Final residual = 5.26869e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00155172, Final residual = 9.50191e-05, No Iterations 5
time step continuity errors : sum local = 2.3417e-08, global = -2.30375e-09, cumulative = 3.74141e-06
GAMG: Solving for p, Initial residual = 0.000350349, Final residual = 6.75578e-07, No Iterations 17
time step continuity errors : sum local = 1.6649e-10, global = 6.23395e-12, cumulative = 3.74142e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00127586, Final residual = 3.87084e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00446983, Final residual = 4.04834e-06, No Iterations 5
ExecutionTime = 4.91 s ClockTime = 5 s
Time = 0.42
Courant Number mean: 0.0927957 max: 0.611356
smoothSolver: Solving for Ux, Initial residual = 0.00100429, Final residual = 5.59975e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00219007, Final residual = 5.20894e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00152711, Final residual = 9.35513e-05, No Iterations 5
time step continuity errors : sum local = 2.30539e-08, global = -2.31647e-09, cumulative = 3.7391e-06
GAMG: Solving for p, Initial residual = 0.000343152, Final residual = 6.66587e-07, No Iterations 17
time step continuity errors : sum local = 1.64264e-10, global = 6.10298e-12, cumulative = 3.73911e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012725, Final residual = 3.81933e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00445539, Final residual = 3.9758e-06, No Iterations 5
ExecutionTime = 4.94 s ClockTime = 5 s
Time = 0.4225
Courant Number mean: 0.0928608 max: 0.611423
smoothSolver: Solving for Ux, Initial residual = 0.0010043, Final residual = 5.5552e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00217774, Final residual = 5.14869e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00155544, Final residual = 9.2357e-05, No Iterations 5
time step continuity errors : sum local = 2.27596e-08, global = -2.32112e-09, cumulative = 3.73679e-06
GAMG: Solving for p, Initial residual = 0.000343466, Final residual = 6.58352e-07, No Iterations 17
time step continuity errors : sum local = 1.62242e-10, global = 5.97876e-12, cumulative = 3.73679e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00126884, Final residual = 3.77368e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00444183, Final residual = 3.90798e-06, No Iterations 5
ExecutionTime = 4.96 s ClockTime = 5 s
Time = 0.425
Courant Number mean: 0.0929256 max: 0.61149
smoothSolver: Solving for Ux, Initial residual = 0.0010043, Final residual = 5.5101e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00216887, Final residual = 5.08903e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0015588, Final residual = 9.3499e-05, No Iterations 5
time step continuity errors : sum local = 2.30402e-08, global = -2.39994e-09, cumulative = 3.73439e-06
GAMG: Solving for p, Initial residual = 0.000339522, Final residual = 6.77312e-07, No Iterations 17
time step continuity errors : sum local = 1.66897e-10, global = 6.34032e-12, cumulative = 3.7344e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00126528, Final residual = 3.72406e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00442931, Final residual = 3.84295e-06, No Iterations 5
ExecutionTime = 4.99 s ClockTime = 5 s
Time = 0.4275
Courant Number mean: 0.09299 max: 0.611557
smoothSolver: Solving for Ux, Initial residual = 0.00100434, Final residual = 5.46566e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00216334, Final residual = 5.02984e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00161368, Final residual = 0.000154353, No Iterations 4
time step continuity errors : sum local = 3.80295e-08, global = 3.27985e-09, cumulative = 3.73768e-06
GAMG: Solving for p, Initial residual = 0.00036221, Final residual = 9.16635e-07, No Iterations 18
time step continuity errors : sum local = 2.2582e-10, global = 2.05949e-11, cumulative = 3.7377e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012613, Final residual = 3.6796e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00441784, Final residual = 3.7789e-06, No Iterations 5
ExecutionTime = 5.02 s ClockTime = 5 s
Time = 0.43
Courant Number mean: 0.0930543 max: 0.611623
smoothSolver: Solving for Ux, Initial residual = 0.00100431, Final residual = 5.42593e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00215949, Final residual = 4.96724e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00158651, Final residual = 0.000106837, No Iterations 5
time step continuity errors : sum local = 2.63192e-08, global = -1.68574e-09, cumulative = 3.73602e-06
GAMG: Solving for p, Initial residual = 0.000370485, Final residual = 7.19094e-07, No Iterations 17
time step continuity errors : sum local = 1.77149e-10, global = 7.18061e-12, cumulative = 3.73602e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125705, Final residual = 3.6362e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00440694, Final residual = 3.71852e-06, No Iterations 5
ExecutionTime = 5.05 s ClockTime = 5 s
Time = 0.4325
Courant Number mean: 0.0931183 max: 0.611689
smoothSolver: Solving for Ux, Initial residual = 0.00100452, Final residual = 5.38722e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00215744, Final residual = 4.91649e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00151609, Final residual = 9.56451e-05, No Iterations 5
time step continuity errors : sum local = 2.35643e-08, global = -2.52877e-09, cumulative = 3.73349e-06
GAMG: Solving for p, Initial residual = 0.000341514, Final residual = 6.9013e-07, No Iterations 17
time step continuity errors : sum local = 1.70038e-10, global = 6.35606e-12, cumulative = 3.7335e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125299, Final residual = 3.59567e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0043953, Final residual = 3.65842e-06, No Iterations 5
ExecutionTime = 5.07 s ClockTime = 5 s
Time = 0.435
Courant Number mean: 0.0931817 max: 0.611756
smoothSolver: Solving for Ux, Initial residual = 0.00100462, Final residual = 5.34847e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00215706, Final residual = 4.85627e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00151954, Final residual = 0.000139814, No Iterations 4
time step continuity errors : sum local = 3.44491e-08, global = 3.00627e-09, cumulative = 3.73651e-06
GAMG: Solving for p, Initial residual = 0.000341704, Final residual = 9.3317e-07, No Iterations 18
time step continuity errors : sum local = 2.29935e-10, global = 2.09784e-11, cumulative = 3.73653e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00124942, Final residual = 3.55678e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00438185, Final residual = 3.60088e-06, No Iterations 5
ExecutionTime = 5.1 s ClockTime = 5 s
Time = 0.4375
Courant Number mean: 0.0932444 max: 0.611822
smoothSolver: Solving for Ux, Initial residual = 0.00100468, Final residual = 5.3105e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00215687, Final residual = 4.79583e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00151778, Final residual = 0.000103968, No Iterations 5
time step continuity errors : sum local = 2.56185e-08, global = -1.87871e-09, cumulative = 3.73465e-06
GAMG: Solving for p, Initial residual = 0.000344092, Final residual = 6.96112e-07, No Iterations 17
time step continuity errors : sum local = 1.71532e-10, global = 6.57261e-12, cumulative = 3.73465e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00124617, Final residual = 3.51964e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00436707, Final residual = 3.53889e-06, No Iterations 5
ExecutionTime = 5.12 s ClockTime = 5 s
Time = 0.44
Courant Number mean: 0.0933069 max: 0.611887
smoothSolver: Solving for Ux, Initial residual = 0.0010046, Final residual = 5.27071e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00215455, Final residual = 4.74637e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00161177, Final residual = 0.000149552, No Iterations 4
time step continuity errors : sum local = 3.68539e-08, global = 2.93602e-09, cumulative = 3.73759e-06
GAMG: Solving for p, Initial residual = 0.000363179, Final residual = 6.81805e-07, No Iterations 18
time step continuity errors : sum local = 1.68032e-10, global = 1.02849e-11, cumulative = 3.7376e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00124313, Final residual = 3.48217e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00435142, Final residual = 3.47932e-06, No Iterations 5
ExecutionTime = 5.15 s ClockTime = 5 s
Time = 0.4425
Courant Number mean: 0.0933689 max: 0.611953
smoothSolver: Solving for Ux, Initial residual = 0.00100454, Final residual = 5.23345e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00215012, Final residual = 4.68694e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0016135, Final residual = 0.000148136, No Iterations 4
time step continuity errors : sum local = 3.65064e-08, global = 1.1486e-09, cumulative = 3.73875e-06
GAMG: Solving for p, Initial residual = 0.000361301, Final residual = 6.2197e-07, No Iterations 18
time step continuity errors : sum local = 1.53287e-10, global = 9.84109e-12, cumulative = 3.73876e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00124007, Final residual = 3.44644e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00433477, Final residual = 3.4227e-06, No Iterations 5
ExecutionTime = 5.18 s ClockTime = 5 s
Time = 0.445
Courant Number mean: 0.0934302 max: 0.612017
smoothSolver: Solving for Ux, Initial residual = 0.00100439, Final residual = 5.1954e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00214321, Final residual = 4.63959e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00156617, Final residual = 0.000145068, No Iterations 4
time step continuity errors : sum local = 3.57508e-08, global = 1.95023e-09, cumulative = 3.74071e-06
GAMG: Solving for p, Initial residual = 0.000355008, Final residual = 5.76849e-07, No Iterations 18
time step continuity errors : sum local = 1.42165e-10, global = 7.6053e-12, cumulative = 3.74072e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00123701, Final residual = 3.41338e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00431759, Final residual = 3.36608e-06, No Iterations 5
ExecutionTime = 5.2 s ClockTime = 5 s
Time = 0.4475
Courant Number mean: 0.0934912 max: 0.612081
smoothSolver: Solving for Ux, Initial residual = 0.00100424, Final residual = 5.15593e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00213354, Final residual = 4.5857e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00159621, Final residual = 0.000157405, No Iterations 4
time step continuity errors : sum local = 3.87909e-08, global = 1.83337e-09, cumulative = 3.74255e-06
GAMG: Solving for p, Initial residual = 0.000360492, Final residual = 6.74157e-07, No Iterations 18
time step continuity errors : sum local = 1.66152e-10, global = 1.0966e-11, cumulative = 3.74256e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00123358, Final residual = 3.37683e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00430139, Final residual = 3.31431e-06, No Iterations 5
ExecutionTime = 5.23 s ClockTime = 5 s
Time = 0.45
Courant Number mean: 0.0935519 max: 0.612145
smoothSolver: Solving for Ux, Initial residual = 0.00100427, Final residual = 5.11903e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00212228, Final residual = 4.53621e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00164949, Final residual = 0.000152347, No Iterations 4
time step continuity errors : sum local = 3.75386e-08, global = 1.79239e-09, cumulative = 3.74435e-06
GAMG: Solving for p, Initial residual = 0.000353192, Final residual = 6.04068e-07, No Iterations 18
time step continuity errors : sum local = 1.48826e-10, global = 8.71962e-12, cumulative = 3.74436e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012299, Final residual = 3.34434e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00428792, Final residual = 3.26714e-06, No Iterations 5
ExecutionTime = 5.26 s ClockTime = 5 s
Time = 0.4525
Courant Number mean: 0.0936123 max: 0.612208
smoothSolver: Solving for Ux, Initial residual = 0.00100426, Final residual = 5.0804e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00210957, Final residual = 4.48512e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00148633, Final residual = 9.33715e-05, No Iterations 5
time step continuity errors : sum local = 2.30011e-08, global = -2.46523e-09, cumulative = 3.7419e-06
GAMG: Solving for p, Initial residual = 0.000328261, Final residual = 7.01018e-07, No Iterations 17
time step continuity errors : sum local = 1.72677e-10, global = 7.25168e-12, cumulative = 3.7419e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00122638, Final residual = 3.30766e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00427505, Final residual = 3.22322e-06, No Iterations 5
ExecutionTime = 5.29 s ClockTime = 5 s
Time = 0.455
Courant Number mean: 0.0936722 max: 0.612271
smoothSolver: Solving for Ux, Initial residual = 0.00100432, Final residual = 5.04379e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00209804, Final residual = 4.4385e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0014237, Final residual = 0.000135992, No Iterations 4
time step continuity errors : sum local = 3.34949e-08, global = 2.83589e-09, cumulative = 3.74474e-06
GAMG: Solving for p, Initial residual = 0.000330705, Final residual = 8.54322e-07, No Iterations 18
time step continuity errors : sum local = 2.10403e-10, global = 1.7779e-11, cumulative = 3.74476e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00122305, Final residual = 3.26546e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0042636, Final residual = 3.18191e-06, No Iterations 5
ExecutionTime = 5.32 s ClockTime = 5 s
Time = 0.4575
Courant Number mean: 0.0937321 max: 0.612333
smoothSolver: Solving for Ux, Initial residual = 0.00100451, Final residual = 5.00541e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0020897, Final residual = 4.38381e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00138696, Final residual = 9.40051e-05, No Iterations 5
time step continuity errors : sum local = 2.31488e-08, global = -2.40685e-09, cumulative = 3.74235e-06
GAMG: Solving for p, Initial residual = 0.000320465, Final residual = 6.68364e-07, No Iterations 17
time step continuity errors : sum local = 1.64576e-10, global = 6.54884e-12, cumulative = 3.74236e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00121953, Final residual = 3.23103e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0042528, Final residual = 3.1428e-06, No Iterations 5
ExecutionTime = 5.34 s ClockTime = 5 s
Time = 0.46
Courant Number mean: 0.0937938 max: 0.612394
smoothSolver: Solving for Ux, Initial residual = 0.00100471, Final residual = 4.97079e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00208204, Final residual = 4.33941e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00146747, Final residual = 0.000135219, No Iterations 4
time step continuity errors : sum local = 3.32934e-08, global = 2.85557e-09, cumulative = 3.74521e-06
GAMG: Solving for p, Initial residual = 0.000328848, Final residual = 8.54764e-07, No Iterations 18
time step continuity errors : sum local = 2.10446e-10, global = 1.81773e-11, cumulative = 3.74523e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00121561, Final residual = 3.1931e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0042424, Final residual = 9.95614e-06, No Iterations 4
ExecutionTime = 5.36 s ClockTime = 5 s
Time = 0.4625
Courant Number mean: 0.0938566 max: 0.612455
smoothSolver: Solving for Ux, Initial residual = 0.00100486, Final residual = 4.93791e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00207802, Final residual = 4.28461e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00159188, Final residual = 0.000148825, No Iterations 4
time step continuity errors : sum local = 3.664e-08, global = 1.61077e-09, cumulative = 3.74684e-06
GAMG: Solving for p, Initial residual = 0.000345623, Final residual = 9.42845e-07, No Iterations 16
time step continuity errors : sum local = 2.32132e-10, global = 1.14485e-11, cumulative = 3.74685e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00121212, Final residual = 3.16377e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00423204, Final residual = 9.85821e-06, No Iterations 4
ExecutionTime = 5.38 s ClockTime = 5 s
Time = 0.465
Courant Number mean: 0.0939196 max: 0.612515
smoothSolver: Solving for Ux, Initial residual = 0.00100486, Final residual = 4.90399e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0020762, Final residual = 4.23768e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00149943, Final residual = 9.41329e-05, No Iterations 5
time step continuity errors : sum local = 2.31745e-08, global = -2.2121e-09, cumulative = 3.74464e-06
GAMG: Solving for p, Initial residual = 0.000329943, Final residual = 5.88959e-07, No Iterations 17
time step continuity errors : sum local = 1.45001e-10, global = 5.12994e-12, cumulative = 3.74465e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012089, Final residual = 3.13103e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0042199, Final residual = 9.7629e-06, No Iterations 4
ExecutionTime = 5.4 s ClockTime = 5 s
Time = 0.4675
Courant Number mean: 0.0939831 max: 0.612574
smoothSolver: Solving for Ux, Initial residual = 0.00100512, Final residual = 4.87255e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00207544, Final residual = 4.19339e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00145871, Final residual = 0.000136178, No Iterations 4
time step continuity errors : sum local = 3.35267e-08, global = 2.88468e-09, cumulative = 3.74753e-06
GAMG: Solving for p, Initial residual = 0.000323369, Final residual = 7.62873e-07, No Iterations 18
time step continuity errors : sum local = 1.87825e-10, global = 1.43331e-11, cumulative = 3.74755e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00120587, Final residual = 3.09737e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00420613, Final residual = 9.66327e-06, No Iterations 4
ExecutionTime = 5.43 s ClockTime = 5 s
Time = 0.47
Courant Number mean: 0.0940465 max: 0.612633
smoothSolver: Solving for Ux, Initial residual = 0.00100527, Final residual = 4.83928e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00207477, Final residual = 4.14257e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00145296, Final residual = 9.77509e-05, No Iterations 5
time step continuity errors : sum local = 2.40654e-08, global = -2.12927e-09, cumulative = 3.74542e-06
GAMG: Solving for p, Initial residual = 0.000317922, Final residual = 5.61839e-07, No Iterations 17
time step continuity errors : sum local = 1.38315e-10, global = 4.77809e-12, cumulative = 3.74542e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012027, Final residual = 3.06438e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00419178, Final residual = 9.56389e-06, No Iterations 4
ExecutionTime = 5.45 s ClockTime = 6 s
Time = 0.4725
Courant Number mean: 0.0941099 max: 0.61269
smoothSolver: Solving for Ux, Initial residual = 0.00100542, Final residual = 4.80663e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00207232, Final residual = 4.10088e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00148577, Final residual = 0.000136915, No Iterations 4
time step continuity errors : sum local = 3.37045e-08, global = 2.91065e-09, cumulative = 3.74833e-06
GAMG: Solving for p, Initial residual = 0.000331359, Final residual = 7.68982e-07, No Iterations 18
time step continuity errors : sum local = 1.8929e-10, global = 1.47321e-11, cumulative = 3.74835e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00119922, Final residual = 3.03676e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0041767, Final residual = 9.46829e-06, No Iterations 4
ExecutionTime = 5.48 s ClockTime = 6 s
Time = 0.475
Courant Number mean: 0.0941732 max: 0.612747
smoothSolver: Solving for Ux, Initial residual = 0.00100549, Final residual = 4.77467e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00206865, Final residual = 4.05267e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00153589, Final residual = 0.000148319, No Iterations 4
time step continuity errors : sum local = 3.65063e-08, global = 1.53735e-09, cumulative = 3.74988e-06
GAMG: Solving for p, Initial residual = 0.000345866, Final residual = 7.84813e-07, No Iterations 16
time step continuity errors : sum local = 1.93168e-10, global = 7.92836e-12, cumulative = 3.74989e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00119635, Final residual = 3.00977e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00416074, Final residual = 9.38006e-06, No Iterations 4
ExecutionTime = 5.5 s ClockTime = 6 s
Time = 0.4775
Courant Number mean: 0.0942363 max: 0.612804
smoothSolver: Solving for Ux, Initial residual = 0.00100544, Final residual = 4.74047e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00206268, Final residual = 4.01035e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00156259, Final residual = 0.000142029, No Iterations 4
time step continuity errors : sum local = 3.49515e-08, global = 2.40438e-09, cumulative = 3.7523e-06
GAMG: Solving for p, Initial residual = 0.000342318, Final residual = 6.45274e-07, No Iterations 18
time step continuity errors : sum local = 1.58782e-10, global = 1.09666e-11, cumulative = 3.75231e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00119355, Final residual = 2.98003e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00414559, Final residual = 9.29536e-06, No Iterations 4
ExecutionTime = 5.52 s ClockTime = 6 s
Time = 0.48
Courant Number mean: 0.0942993 max: 0.612859
smoothSolver: Solving for Ux, Initial residual = 0.0010055, Final residual = 4.71038e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00205458, Final residual = 3.96763e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00152748, Final residual = 0.000144712, No Iterations 4
time step continuity errors : sum local = 3.5608e-08, global = 1.70419e-09, cumulative = 3.75401e-06
GAMG: Solving for p, Initial residual = 0.000348913, Final residual = 7.64553e-07, No Iterations 16
time step continuity errors : sum local = 1.88137e-10, global = 7.56942e-12, cumulative = 3.75402e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00119091, Final residual = 2.95411e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00413459, Final residual = 9.21272e-06, No Iterations 4
ExecutionTime = 5.55 s ClockTime = 6 s
Time = 0.4825
Courant Number mean: 0.0943621 max: 0.612914
smoothSolver: Solving for Ux, Initial residual = 0.00100541, Final residual = 4.67492e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00204418, Final residual = 3.9241e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00148421, Final residual = 8.62178e-05, No Iterations 5
time step continuity errors : sum local = 2.12145e-08, global = -2.05218e-09, cumulative = 3.75197e-06
GAMG: Solving for p, Initial residual = 0.000322675, Final residual = 5.2114e-07, No Iterations 17
time step continuity errors : sum local = 1.28233e-10, global = 4.41951e-12, cumulative = 3.75197e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00118811, Final residual = 2.92523e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00412333, Final residual = 9.1395e-06, No Iterations 4
ExecutionTime = 5.57 s ClockTime = 6 s
Time = 0.485
Courant Number mean: 0.0944248 max: 0.612967
smoothSolver: Solving for Ux, Initial residual = 0.00100551, Final residual = 4.64599e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00203376, Final residual = 3.88458e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00148651, Final residual = 0.00013649, No Iterations 4
time step continuity errors : sum local = 3.35861e-08, global = 3.17163e-09, cumulative = 3.75514e-06
GAMG: Solving for p, Initial residual = 0.000325739, Final residual = 6.7291e-07, No Iterations 18
time step continuity errors : sum local = 1.65589e-10, global = 1.18622e-11, cumulative = 3.75516e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0011852, Final residual = 2.89811e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00411181, Final residual = 9.06784e-06, No Iterations 4
ExecutionTime = 5.59 s ClockTime = 6 s
Time = 0.4875
Courant Number mean: 0.0944875 max: 0.613021
smoothSolver: Solving for Ux, Initial residual = 0.0010054, Final residual = 4.61233e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00202439, Final residual = 3.83927e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00145928, Final residual = 8.59133e-05, No Iterations 5
time step continuity errors : sum local = 2.11408e-08, global = -1.96519e-09, cumulative = 3.75319e-06
GAMG: Solving for p, Initial residual = 0.000307912, Final residual = 5.11241e-07, No Iterations 17
time step continuity errors : sum local = 1.2581e-10, global = 4.29445e-12, cumulative = 3.75319e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00118204, Final residual = 2.87174e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00410085, Final residual = 8.99921e-06, No Iterations 4
ExecutionTime = 5.62 s ClockTime = 6 s
Time = 0.49
Courant Number mean: 0.0945501 max: 0.613073
smoothSolver: Solving for Ux, Initial residual = 0.00100538, Final residual = 4.58228e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00201549, Final residual = 3.80079e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00152841, Final residual = 0.00013716, No Iterations 4
time step continuity errors : sum local = 3.37563e-08, global = 3.2076e-09, cumulative = 3.7564e-06
GAMG: Solving for p, Initial residual = 0.000328447, Final residual = 6.73521e-07, No Iterations 18
time step continuity errors : sum local = 1.65781e-10, global = 1.19165e-11, cumulative = 3.75641e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00117862, Final residual = 2.84739e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00409073, Final residual = 8.94691e-06, No Iterations 4
ExecutionTime = 5.65 s ClockTime = 6 s
Time = 0.4925
Courant Number mean: 0.0946127 max: 0.613124
smoothSolver: Solving for Ux, Initial residual = 0.00100536, Final residual = 4.55346e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00200889, Final residual = 3.75584e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00147999, Final residual = 8.5467e-05, No Iterations 5
time step continuity errors : sum local = 2.10383e-08, global = -1.88447e-09, cumulative = 3.75453e-06
GAMG: Solving for p, Initial residual = 0.000303167, Final residual = 9.99432e-07, No Iterations 15
time step continuity errors : sum local = 2.46052e-10, global = 8.59494e-12, cumulative = 3.75454e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00117547, Final residual = 2.82636e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00408095, Final residual = 8.89627e-06, No Iterations 4
ExecutionTime = 5.67 s ClockTime = 6 s
Time = 0.495
Courant Number mean: 0.0946754 max: 0.613175
smoothSolver: Solving for Ux, Initial residual = 0.00100538, Final residual = 4.52588e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00200296, Final residual = 3.71858e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00144372, Final residual = 0.000136677, No Iterations 4
time step continuity errors : sum local = 3.36461e-08, global = 3.31041e-09, cumulative = 3.75785e-06
GAMG: Solving for p, Initial residual = 0.000321465, Final residual = 6.61218e-07, No Iterations 18
time step continuity errors : sum local = 1.62767e-10, global = 1.15896e-11, cumulative = 3.75786e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0011725, Final residual = 2.80486e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00407009, Final residual = 8.8517e-06, No Iterations 4
ExecutionTime = 5.69 s ClockTime = 6 s
Time = 0.4975
Courant Number mean: 0.094738 max: 0.613225
smoothSolver: Solving for Ux, Initial residual = 0.00100529, Final residual = 4.49807e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00199874, Final residual = 3.67427e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00140539, Final residual = 8.33938e-05, No Iterations 5
time step continuity errors : sum local = 2.05252e-08, global = -1.80295e-09, cumulative = 3.75606e-06
GAMG: Solving for p, Initial residual = 0.000297504, Final residual = 4.94563e-07, No Iterations 17
time step continuity errors : sum local = 1.21717e-10, global = 4.15121e-12, cumulative = 3.75606e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0011695, Final residual = 2.78249e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00405792, Final residual = 8.80264e-06, No Iterations 4
ExecutionTime = 5.72 s ClockTime = 6 s
Time = 0.5
Courant Number mean: 0.0948005 max: 0.613275
smoothSolver: Solving for Ux, Initial residual = 0.00100525, Final residual = 4.47051e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00199566, Final residual = 3.63864e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00154358, Final residual = 0.00013912, No Iterations 4
time step continuity errors : sum local = 3.42339e-08, global = 3.28458e-09, cumulative = 3.75935e-06
GAMG: Solving for p, Initial residual = 0.000325761, Final residual = 6.95331e-07, No Iterations 18
time step continuity errors : sum local = 1.71087e-10, global = 1.30464e-11, cumulative = 3.75936e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116654, Final residual = 2.75828e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0040451, Final residual = 8.76263e-06, No Iterations 4
ExecutionTime = 5.76 s ClockTime = 6 s
Time = 0.5025
Courant Number mean: 0.0948633 max: 0.613323
smoothSolver: Solving for Ux, Initial residual = 0.00100523, Final residual = 4.44366e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00199393, Final residual = 3.59649e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00147027, Final residual = 7.6821e-05, No Iterations 5
time step continuity errors : sum local = 1.88997e-08, global = -1.64659e-09, cumulative = 3.75771e-06
GAMG: Solving for p, Initial residual = 0.000298851, Final residual = 5.19442e-07, No Iterations 17
time step continuity errors : sum local = 1.27786e-10, global = 4.64413e-12, cumulative = 3.75772e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116338, Final residual = 2.73244e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00403145, Final residual = 8.72213e-06, No Iterations 4
ExecutionTime = 5.79 s ClockTime = 6 s
Time = 0.505
Courant Number mean: 0.0949263 max: 0.613371
smoothSolver: Solving for Ux, Initial residual = 0.00100551, Final residual = 4.41684e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00199239, Final residual = 3.5637e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00138667, Final residual = 0.000136729, No Iterations 4
time step continuity errors : sum local = 3.36357e-08, global = 3.38093e-09, cumulative = 3.7611e-06
GAMG: Solving for p, Initial residual = 0.000315506, Final residual = 5.97379e-07, No Iterations 18
time step continuity errors : sum local = 1.46954e-10, global = 9.4216e-12, cumulative = 3.76111e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116035, Final residual = 2.70474e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00401732, Final residual = 8.68149e-06, No Iterations 4
ExecutionTime = 5.82 s ClockTime = 6 s
Time = 0.5075
Courant Number mean: 0.0949892 max: 0.613419
smoothSolver: Solving for Ux, Initial residual = 0.0010057, Final residual = 4.38745e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00198962, Final residual = 3.52305e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0013593, Final residual = 7.96425e-05, No Iterations 5
time step continuity errors : sum local = 1.95903e-08, global = -1.6854e-09, cumulative = 3.75942e-06
GAMG: Solving for p, Initial residual = 0.000288342, Final residual = 9.60922e-07, No Iterations 15
time step continuity errors : sum local = 2.36369e-10, global = 8.12973e-12, cumulative = 3.75943e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00115726, Final residual = 2.68367e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00400309, Final residual = 8.6547e-06, No Iterations 4
ExecutionTime = 5.84 s ClockTime = 6 s
Time = 0.51
Courant Number mean: 0.0950525 max: 0.613465
smoothSolver: Solving for Ux, Initial residual = 0.00100589, Final residual = 4.36116e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00198531, Final residual = 3.49101e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00147995, Final residual = 0.000134968, No Iterations 4
time step continuity errors : sum local = 3.32e-08, global = 3.36456e-09, cumulative = 3.76279e-06
GAMG: Solving for p, Initial residual = 0.000318776, Final residual = 5.99614e-07, No Iterations 18
time step continuity errors : sum local = 1.47501e-10, global = 9.59052e-12, cumulative = 3.7628e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00115409, Final residual = 2.66558e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0039922, Final residual = 8.62851e-06, No Iterations 4
ExecutionTime = 5.86 s ClockTime = 6 s
Time = 0.5125
Courant Number mean: 0.0951158 max: 0.613512
smoothSolver: Solving for Ux, Initial residual = 0.001006, Final residual = 4.33341e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00197916, Final residual = 3.4525e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00147457, Final residual = 0.000144016, No Iterations 4
time step continuity errors : sum local = 3.54261e-08, global = 1.92851e-09, cumulative = 3.76473e-06
GAMG: Solving for p, Initial residual = 0.000335038, Final residual = 7.58149e-07, No Iterations 16
time step continuity errors : sum local = 1.86511e-10, global = 7.67633e-12, cumulative = 3.76474e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00115156, Final residual = 2.64377e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00398263, Final residual = 8.60484e-06, No Iterations 4
ExecutionTime = 5.89 s ClockTime = 6 s
Time = 0.515
Courant Number mean: 0.0951792 max: 0.613558
smoothSolver: Solving for Ux, Initial residual = 0.0010061, Final residual = 4.30575e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00197156, Final residual = 3.41887e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00144113, Final residual = 0.000137532, No Iterations 4
time step continuity errors : sum local = 3.38315e-08, global = 2.78793e-09, cumulative = 3.76753e-06
GAMG: Solving for p, Initial residual = 0.000325539, Final residual = 9.8536e-07, No Iterations 16
time step continuity errors : sum local = 2.42395e-10, global = 1.38875e-11, cumulative = 3.76754e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114901, Final residual = 2.62105e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00397242, Final residual = 8.57438e-06, No Iterations 4
ExecutionTime = 5.91 s ClockTime = 6 s
Time = 0.5175
Courant Number mean: 0.0952431 max: 0.613603
smoothSolver: Solving for Ux, Initial residual = 0.00100621, Final residual = 4.27967e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00196333, Final residual = 3.38376e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00152519, Final residual = 0.000143273, No Iterations 4
time step continuity errors : sum local = 3.52401e-08, global = 2.44816e-09, cumulative = 3.76999e-06
GAMG: Solving for p, Initial residual = 0.000331014, Final residual = 9.36809e-07, No Iterations 16
time step continuity errors : sum local = 2.30407e-10, global = 1.29247e-11, cumulative = 3.77e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114649, Final residual = 2.60152e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00396241, Final residual = 8.54857e-06, No Iterations 4
ExecutionTime = 5.93 s ClockTime = 6 s
Time = 0.52
Courant Number mean: 0.0953071 max: 0.613648
smoothSolver: Solving for Ux, Initial residual = 0.00100629, Final residual = 4.25278e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00195602, Final residual = 3.34976e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0014524, Final residual = 0.000142906, No Iterations 4
time step continuity errors : sum local = 3.51437e-08, global = 2.60374e-09, cumulative = 3.77261e-06
GAMG: Solving for p, Initial residual = 0.000326815, Final residual = 9.46471e-07, No Iterations 16
time step continuity errors : sum local = 2.32751e-10, global = 1.30134e-11, cumulative = 3.77262e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114387, Final residual = 2.58254e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00395266, Final residual = 8.52559e-06, No Iterations 4
ExecutionTime = 5.95 s ClockTime = 6 s
Time = 0.5225
Courant Number mean: 0.0953713 max: 0.613693
smoothSolver: Solving for Ux, Initial residual = 0.00100632, Final residual = 4.22635e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00194881, Final residual = 3.31509e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00141153, Final residual = 7.42085e-05, No Iterations 5
time step continuity errors : sum local = 1.82463e-08, global = -1.72195e-09, cumulative = 3.7709e-06
GAMG: Solving for p, Initial residual = 0.000284211, Final residual = 9.84533e-07, No Iterations 15
time step continuity errors : sum local = 2.42045e-10, global = 9.29828e-12, cumulative = 3.77091e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114139, Final residual = 2.56652e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00394357, Final residual = 8.50183e-06, No Iterations 4
ExecutionTime = 5.97 s ClockTime = 6 s
Time = 0.525
Courant Number mean: 0.0954357 max: 0.613737
smoothSolver: Solving for Ux, Initial residual = 0.00100633, Final residual = 4.20258e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0019417, Final residual = 3.28261e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00137061, Final residual = 0.000129698, No Iterations 4
time step continuity errors : sum local = 3.18852e-08, global = 3.41207e-09, cumulative = 3.77432e-06
GAMG: Solving for p, Initial residual = 0.000304227, Final residual = 6.03094e-07, No Iterations 18
time step continuity errors : sum local = 1.48264e-10, global = 1.00147e-11, cumulative = 3.77433e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113928, Final residual = 2.54957e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00393405, Final residual = 8.47999e-06, No Iterations 4
ExecutionTime = 6 s ClockTime = 6 s
Time = 0.5275
Courant Number mean: 0.0955002 max: 0.613782
smoothSolver: Solving for Ux, Initial residual = 0.00100625, Final residual = 4.17624e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00193639, Final residual = 3.24535e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00134164, Final residual = 7.47314e-05, No Iterations 5
time step continuity errors : sum local = 1.83704e-08, global = -1.67133e-09, cumulative = 3.77266e-06
GAMG: Solving for p, Initial residual = 0.000279558, Final residual = 9.71657e-07, No Iterations 15
time step continuity errors : sum local = 2.38851e-10, global = 9.92342e-12, cumulative = 3.77267e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113721, Final residual = 2.53517e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00392285, Final residual = 8.45263e-06, No Iterations 4
ExecutionTime = 6.02 s ClockTime = 6 s
Time = 0.53
Courant Number mean: 0.0955651 max: 0.613826
smoothSolver: Solving for Ux, Initial residual = 0.00100637, Final residual = 4.15641e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00193061, Final residual = 3.21521e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00142278, Final residual = 0.00013091, No Iterations 4
time step continuity errors : sum local = 3.21805e-08, global = 3.35789e-09, cumulative = 3.77603e-06
GAMG: Solving for p, Initial residual = 0.000307075, Final residual = 5.8015e-07, No Iterations 18
time step continuity errors : sum local = 1.42614e-10, global = 9.21359e-12, cumulative = 3.77604e-06
smoothSolver: Solving for epsilon, Initial residual = 0.001135, Final residual = 2.52173e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00391068, Final residual = 8.42251e-06, No Iterations 4
ExecutionTime = 6.05 s ClockTime = 6 s
Time = 0.5325
Courant Number mean: 0.0956301 max: 0.613869
smoothSolver: Solving for Ux, Initial residual = 0.00100632, Final residual = 4.12813e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00192512, Final residual = 3.17877e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0013287, Final residual = 7.78097e-05, No Iterations 5
time step continuity errors : sum local = 1.91253e-08, global = -1.69199e-09, cumulative = 3.77434e-06
GAMG: Solving for p, Initial residual = 0.000278217, Final residual = 9.09437e-07, No Iterations 15
time step continuity errors : sum local = 2.23534e-10, global = 7.43246e-12, cumulative = 3.77435e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113276, Final residual = 2.50789e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00389786, Final residual = 8.39197e-06, No Iterations 4
ExecutionTime = 6.08 s ClockTime = 6 s
Time = 0.535
Courant Number mean: 0.0956952 max: 0.613913
smoothSolver: Solving for Ux, Initial residual = 0.00100639, Final residual = 4.10727e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00192097, Final residual = 3.14905e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00134385, Final residual = 0.000130218, No Iterations 4
time step continuity errors : sum local = 3.20071e-08, global = 3.32933e-09, cumulative = 3.77768e-06
GAMG: Solving for p, Initial residual = 0.000295137, Final residual = 6.39943e-07, No Iterations 18
time step continuity errors : sum local = 1.57304e-10, global = 1.14302e-11, cumulative = 3.77769e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113038, Final residual = 2.4954e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00388474, Final residual = 8.35895e-06, No Iterations 4
ExecutionTime = 6.1 s ClockTime = 6 s
Time = 0.5375
Courant Number mean: 0.0957605 max: 0.613957
smoothSolver: Solving for Ux, Initial residual = 0.00100637, Final residual = 4.08336e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0019178, Final residual = 3.11579e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00139993, Final residual = 8.02051e-05, No Iterations 5
time step continuity errors : sum local = 1.97152e-08, global = -1.69345e-09, cumulative = 3.776e-06
GAMG: Solving for p, Initial residual = 0.000278731, Final residual = 9.22512e-07, No Iterations 15
time step continuity errors : sum local = 2.2678e-10, global = 7.57151e-12, cumulative = 3.77601e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112798, Final residual = 2.48121e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00387114, Final residual = 8.32751e-06, No Iterations 4
ExecutionTime = 6.12 s ClockTime = 6 s
Time = 0.54
Courant Number mean: 0.0958258 max: 0.614
smoothSolver: Solving for Ux, Initial residual = 0.00100638, Final residual = 4.06019e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00191453, Final residual = 3.08704e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00148953, Final residual = 0.00012862, No Iterations 4
time step continuity errors : sum local = 3.16213e-08, global = 3.28093e-09, cumulative = 3.77929e-06
GAMG: Solving for p, Initial residual = 0.000307831, Final residual = 6.92832e-07, No Iterations 18
time step continuity errors : sum local = 1.70359e-10, global = 1.4422e-11, cumulative = 3.7793e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112545, Final residual = 2.46876e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0038588, Final residual = 8.3017e-06, No Iterations 4
ExecutionTime = 6.15 s ClockTime = 6 s
Time = 0.5425
Courant Number mean: 0.0958914 max: 0.614043
smoothSolver: Solving for Ux, Initial residual = 0.00100637, Final residual = 4.03783e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00191074, Final residual = 3.05459e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00149237, Final residual = 0.00014757, No Iterations 4
time step continuity errors : sum local = 3.62876e-08, global = 1.79749e-09, cumulative = 3.7811e-06
GAMG: Solving for p, Initial residual = 0.000322342, Final residual = 7.58764e-07, No Iterations 16
time step continuity errors : sum local = 1.86613e-10, global = 7.82185e-12, cumulative = 3.78111e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112266, Final residual = 2.45079e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00384953, Final residual = 8.27794e-06, No Iterations 4
ExecutionTime = 6.18 s ClockTime = 6 s
Time = 0.545
Courant Number mean: 0.095957 max: 0.614087
smoothSolver: Solving for Ux, Initial residual = 0.00100652, Final residual = 4.01259e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0019067, Final residual = 3.02605e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0013455, Final residual = 7.73467e-05, No Iterations 5
time step continuity errors : sum local = 1.90208e-08, global = -1.82348e-09, cumulative = 3.77928e-06
GAMG: Solving for p, Initial residual = 0.000269406, Final residual = 9.8651e-07, No Iterations 15
time step continuity errors : sum local = 2.42582e-10, global = 1.10048e-11, cumulative = 3.77929e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111973, Final residual = 2.43825e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00384054, Final residual = 8.2483e-06, No Iterations 4
ExecutionTime = 6.2 s ClockTime = 6 s
Time = 0.5475
Courant Number mean: 0.0960228 max: 0.61413
smoothSolver: Solving for Ux, Initial residual = 0.00100669, Final residual = 3.99466e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00190143, Final residual = 2.99899e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00151275, Final residual = 0.000127179, No Iterations 4
time step continuity errors : sum local = 3.12693e-08, global = 3.16807e-09, cumulative = 3.78246e-06
GAMG: Solving for p, Initial residual = 0.000298804, Final residual = 6.39097e-07, No Iterations 18
time step continuity errors : sum local = 1.57109e-10, global = 1.1188e-11, cumulative = 3.78247e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111688, Final residual = 2.4222e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00383107, Final residual = 8.22494e-06, No Iterations 4
ExecutionTime = 6.23 s ClockTime = 6 s
Time = 0.55
Courant Number mean: 0.0960887 max: 0.614173
smoothSolver: Solving for Ux, Initial residual = 0.00100671, Final residual = 3.96523e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00189513, Final residual = 2.96734e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00142525, Final residual = 0.000142509, No Iterations 4
time step continuity errors : sum local = 3.50281e-08, global = 1.90172e-09, cumulative = 3.78437e-06
GAMG: Solving for p, Initial residual = 0.000316392, Final residual = 8.18828e-07, No Iterations 16
time step continuity errors : sum local = 2.01261e-10, global = 9.45932e-12, cumulative = 3.78438e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111395, Final residual = 2.41079e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00382159, Final residual = 8.19998e-06, No Iterations 4
ExecutionTime = 6.25 s ClockTime = 6 s
Time = 0.5525
Courant Number mean: 0.0961545 max: 0.614215
smoothSolver: Solving for Ux, Initial residual = 0.00100683, Final residual = 3.94456e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00188942, Final residual = 2.93928e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00141062, Final residual = 0.000137627, No Iterations 4
time step continuity errors : sum local = 3.38237e-08, global = 2.22129e-09, cumulative = 3.78661e-06
GAMG: Solving for p, Initial residual = 0.000309575, Final residual = 7.7045e-07, No Iterations 16
time step continuity errors : sum local = 1.89347e-10, global = 8.00889e-12, cumulative = 3.78661e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111101, Final residual = 2.39961e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00381222, Final residual = 8.174e-06, No Iterations 4
ExecutionTime = 6.28 s ClockTime = 6 s
Time = 0.555
Courant Number mean: 0.0962202 max: 0.614258
smoothSolver: Solving for Ux, Initial residual = 0.00100686, Final residual = 3.91962e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00188376, Final residual = 2.91039e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00133159, Final residual = 8.08864e-05, No Iterations 5
time step continuity errors : sum local = 1.98769e-08, global = -1.86855e-09, cumulative = 3.78474e-06
GAMG: Solving for p, Initial residual = 0.000279973, Final residual = 8.82846e-07, No Iterations 15
time step continuity errors : sum local = 2.1695e-10, global = 7.01303e-12, cumulative = 3.78475e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110871, Final residual = 2.391e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00380295, Final residual = 8.14847e-06, No Iterations 4
ExecutionTime = 6.31 s ClockTime = 6 s
Time = 0.5575
Courant Number mean: 0.096286 max: 0.6143
smoothSolver: Solving for Ux, Initial residual = 0.00100693, Final residual = 3.902e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00187765, Final residual = 2.88378e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00135152, Final residual = 0.000129784, No Iterations 4
time step continuity errors : sum local = 3.18916e-08, global = 3.05899e-09, cumulative = 3.78781e-06
GAMG: Solving for p, Initial residual = 0.000296356, Final residual = 6.66871e-07, No Iterations 18
time step continuity errors : sum local = 1.63871e-10, global = 1.16119e-11, cumulative = 3.78782e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110663, Final residual = 2.38088e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00379304, Final residual = 8.1242e-06, No Iterations 4
ExecutionTime = 6.33 s ClockTime = 6 s
Time = 0.56
Courant Number mean: 0.0963518 max: 0.614342
smoothSolver: Solving for Ux, Initial residual = 0.00100692, Final residual = 3.88103e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00187206, Final residual = 2.85421e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00136716, Final residual = 8.51195e-05, No Iterations 5
time step continuity errors : sum local = 2.09152e-08, global = -1.85568e-09, cumulative = 3.78597e-06
GAMG: Solving for p, Initial residual = 0.000282441, Final residual = 8.72981e-07, No Iterations 15
time step continuity errors : sum local = 2.14506e-10, global = 6.86213e-12, cumulative = 3.78597e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110457, Final residual = 2.37151e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00378181, Final residual = 8.10087e-06, No Iterations 4
ExecutionTime = 6.36 s ClockTime = 6 s
Time = 0.5625
Courant Number mean: 0.0964177 max: 0.614384
smoothSolver: Solving for Ux, Initial residual = 0.00100692, Final residual = 3.85923e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00186762, Final residual = 2.82778e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00138314, Final residual = 0.000129888, No Iterations 4
time step continuity errors : sum local = 3.19121e-08, global = 2.99914e-09, cumulative = 3.78897e-06
GAMG: Solving for p, Initial residual = 0.000291267, Final residual = 6.8364e-07, No Iterations 18
time step continuity errors : sum local = 1.6795e-10, global = 1.2365e-11, cumulative = 3.78899e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110249, Final residual = 2.36112e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00377014, Final residual = 8.06787e-06, No Iterations 4
ExecutionTime = 6.38 s ClockTime = 6 s
Time = 0.565
Courant Number mean: 0.0964835 max: 0.614426
smoothSolver: Solving for Ux, Initial residual = 0.001007, Final residual = 3.84123e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00186302, Final residual = 2.79857e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00140368, Final residual = 0.00013709, No Iterations 4
time step continuity errors : sum local = 3.36759e-08, global = 1.68216e-09, cumulative = 3.79067e-06
GAMG: Solving for p, Initial residual = 0.00029772, Final residual = 6.9596e-07, No Iterations 16
time step continuity errors : sum local = 1.70961e-10, global = 6.82836e-12, cumulative = 3.79067e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110046, Final residual = 2.3525e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00375814, Final residual = 8.03835e-06, No Iterations 4
ExecutionTime = 6.4 s ClockTime = 6 s
Time = 0.5675
Courant Number mean: 0.0965492 max: 0.614468
smoothSolver: Solving for Ux, Initial residual = 0.00100711, Final residual = 3.81582e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00185768, Final residual = 2.77103e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00133308, Final residual = 8.27293e-05, No Iterations 5
time step continuity errors : sum local = 2.03196e-08, global = -1.96232e-09, cumulative = 3.78871e-06
GAMG: Solving for p, Initial residual = 0.000272919, Final residual = 8.46373e-07, No Iterations 15
time step continuity errors : sum local = 2.07879e-10, global = 6.68621e-12, cumulative = 3.78872e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109827, Final residual = 2.33968e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00374588, Final residual = 8.00986e-06, No Iterations 4
ExecutionTime = 6.43 s ClockTime = 6 s
Time = 0.57
Courant Number mean: 0.0966153 max: 0.614509
smoothSolver: Solving for Ux, Initial residual = 0.00100733, Final residual = 3.80092e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00185183, Final residual = 2.74621e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0014903, Final residual = 0.000130715, No Iterations 4
time step continuity errors : sum local = 3.21027e-08, global = 3.00695e-09, cumulative = 3.79173e-06
GAMG: Solving for p, Initial residual = 0.000296551, Final residual = 7.38413e-07, No Iterations 18
time step continuity errors : sum local = 1.81344e-10, global = 1.50751e-11, cumulative = 3.79174e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109603, Final residual = 2.32799e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00373327, Final residual = 7.98367e-06, No Iterations 4
ExecutionTime = 6.45 s ClockTime = 7 s
Time = 0.5725
Courant Number mean: 0.0966817 max: 0.61455
smoothSolver: Solving for Ux, Initial residual = 0.0010074, Final residual = 3.77951e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00184816, Final residual = 2.71913e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00131447, Final residual = 0.000130813, No Iterations 4
time step continuity errors : sum local = 3.21238e-08, global = 1.80469e-09, cumulative = 3.79355e-06
GAMG: Solving for p, Initial residual = 0.000290867, Final residual = 7.21976e-07, No Iterations 16
time step continuity errors : sum local = 1.77307e-10, global = 7.41901e-12, cumulative = 3.79355e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010938, Final residual = 2.3174e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00372311, Final residual = 7.95376e-06, No Iterations 4
ExecutionTime = 6.48 s ClockTime = 7 s
Time = 0.575
Courant Number mean: 0.0967484 max: 0.61459
smoothSolver: Solving for Ux, Initial residual = 0.00100748, Final residual = 3.75645e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00184457, Final residual = 2.69251e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00130119, Final residual = 8.65772e-05, No Iterations 5
time step continuity errors : sum local = 2.12606e-08, global = -2.30033e-09, cumulative = 3.79125e-06
GAMG: Solving for p, Initial residual = 0.000273054, Final residual = 9.51782e-07, No Iterations 15
time step continuity errors : sum local = 2.33732e-10, global = 9.25442e-12, cumulative = 3.79126e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109166, Final residual = 2.30899e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00371497, Final residual = 7.93201e-06, No Iterations 4
ExecutionTime = 6.5 s ClockTime = 7 s
Time = 0.5775
Courant Number mean: 0.0968154 max: 0.61463
smoothSolver: Solving for Ux, Initial residual = 0.00100765, Final residual = 3.74342e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00184087, Final residual = 2.67051e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00128287, Final residual = 0.000124358, No Iterations 4
time step continuity errors : sum local = 3.0541e-08, global = 2.92088e-09, cumulative = 3.79418e-06
GAMG: Solving for p, Initial residual = 0.00027768, Final residual = 7.11241e-07, No Iterations 18
time step continuity errors : sum local = 1.7468e-10, global = 1.41395e-11, cumulative = 3.7942e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108934, Final residual = 2.29538e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00370681, Final residual = 7.90588e-06, No Iterations 4
ExecutionTime = 6.53 s ClockTime = 7 s
Time = 0.58
Courant Number mean: 0.0968824 max: 0.61467
smoothSolver: Solving for Ux, Initial residual = 0.00100763, Final residual = 3.71739e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00183655, Final residual = 2.6423e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00134875, Final residual = 0.000131849, No Iterations 4
time step continuity errors : sum local = 3.23819e-08, global = 2.52855e-09, cumulative = 3.79673e-06
GAMG: Solving for p, Initial residual = 0.000298735, Final residual = 8.74658e-07, No Iterations 17
time step continuity errors : sum local = 2.14824e-10, global = -3.51378e-11, cumulative = 3.79669e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108701, Final residual = 2.28703e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00369787, Final residual = 7.88167e-06, No Iterations 4
ExecutionTime = 6.55 s ClockTime = 7 s
Time = 0.5825
Courant Number mean: 0.0969497 max: 0.61471
smoothSolver: Solving for Ux, Initial residual = 0.00100769, Final residual = 3.70431e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00183078, Final residual = 2.61884e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00138405, Final residual = 0.000130257, No Iterations 4
time step continuity errors : sum local = 3.19956e-08, global = 1.9914e-09, cumulative = 3.79868e-06
GAMG: Solving for p, Initial residual = 0.000296627, Final residual = 9.13695e-07, No Iterations 16
time step continuity errors : sum local = 2.24447e-10, global = 1.70762e-11, cumulative = 3.7987e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108457, Final residual = 2.27383e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00368873, Final residual = 7.85665e-06, No Iterations 4
ExecutionTime = 6.57 s ClockTime = 7 s
Time = 0.585
Courant Number mean: 0.0970172 max: 0.614749
smoothSolver: Solving for Ux, Initial residual = 0.00100773, Final residual = 3.67944e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0018261, Final residual = 2.59465e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0013328, Final residual = 0.000122538, No Iterations 4
time step continuity errors : sum local = 3.0103e-08, global = 2.55227e-09, cumulative = 3.80125e-06
GAMG: Solving for p, Initial residual = 0.000285434, Final residual = 6.64576e-07, No Iterations 18
time step continuity errors : sum local = 1.63278e-10, global = 1.30167e-11, cumulative = 3.80126e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108214, Final residual = 2.25792e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00367956, Final residual = 7.83166e-06, No Iterations 4
ExecutionTime = 6.6 s ClockTime = 7 s
Time = 0.5875
Courant Number mean: 0.0970849 max: 0.614787
smoothSolver: Solving for Ux, Initial residual = 0.00100776, Final residual = 3.66148e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0018215, Final residual = 2.57003e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00137719, Final residual = 0.000127106, No Iterations 4
time step continuity errors : sum local = 3.12303e-08, global = 2.48291e-09, cumulative = 3.80375e-06
GAMG: Solving for p, Initial residual = 0.000292223, Final residual = 9.2869e-07, No Iterations 16
time step continuity errors : sum local = 2.28203e-10, global = 2.60552e-11, cumulative = 3.80377e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010803, Final residual = 2.24971e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00367011, Final residual = 7.80851e-06, No Iterations 4
ExecutionTime = 6.62 s ClockTime = 7 s
Time = 0.59
Courant Number mean: 0.0971527 max: 0.614825
smoothSolver: Solving for Ux, Initial residual = 0.00100781, Final residual = 3.64445e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00181658, Final residual = 2.54686e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00139358, Final residual = 0.00012002, No Iterations 4
time step continuity errors : sum local = 2.94947e-08, global = 2.40663e-09, cumulative = 3.80618e-06
GAMG: Solving for p, Initial residual = 0.000285141, Final residual = 6.01094e-07, No Iterations 18
time step continuity errors : sum local = 1.47731e-10, global = 1.05998e-11, cumulative = 3.80619e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010784, Final residual = 2.23965e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00366003, Final residual = 7.78277e-06, No Iterations 4
ExecutionTime = 6.64 s ClockTime = 7 s
Time = 0.5925
Courant Number mean: 0.0972207 max: 0.614863
smoothSolver: Solving for Ux, Initial residual = 0.00100776, Final residual = 3.62294e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00181162, Final residual = 2.52259e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00146067, Final residual = 0.000128917, No Iterations 4
time step continuity errors : sum local = 3.16822e-08, global = 2.60877e-09, cumulative = 3.8088e-06
GAMG: Solving for p, Initial residual = 0.000292131, Final residual = 9.64708e-07, No Iterations 16
time step continuity errors : sum local = 2.37077e-10, global = 2.9884e-11, cumulative = 3.80883e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107636, Final residual = 2.22987e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00364928, Final residual = 7.75638e-06, No Iterations 4
ExecutionTime = 6.67 s ClockTime = 7 s
Time = 0.595
Courant Number mean: 0.0972891 max: 0.6149
smoothSolver: Solving for Ux, Initial residual = 0.0010079, Final residual = 3.61053e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0018063, Final residual = 2.49993e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00145466, Final residual = 0.000126251, No Iterations 4
time step continuity errors : sum local = 3.10239e-08, global = 2.49765e-09, cumulative = 3.81133e-06
GAMG: Solving for p, Initial residual = 0.000288842, Final residual = 9.29253e-07, No Iterations 16
time step continuity errors : sum local = 2.28322e-10, global = 2.02871e-11, cumulative = 3.81135e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107434, Final residual = 2.22122e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0036385, Final residual = 7.73021e-06, No Iterations 4
ExecutionTime = 6.69 s ClockTime = 7 s
Time = 0.5975
Courant Number mean: 0.0973576 max: 0.614936
smoothSolver: Solving for Ux, Initial residual = 0.00100789, Final residual = 3.58864e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00180213, Final residual = 2.4764e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00137541, Final residual = 0.000121015, No Iterations 4
time step continuity errors : sum local = 2.97344e-08, global = 2.53196e-09, cumulative = 3.81388e-06
GAMG: Solving for p, Initial residual = 0.000281979, Final residual = 6.27371e-07, No Iterations 18
time step continuity errors : sum local = 1.54158e-10, global = 1.20496e-11, cumulative = 3.81389e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107235, Final residual = 2.21155e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00362722, Final residual = 7.70209e-06, No Iterations 4
ExecutionTime = 6.71 s ClockTime = 7 s
Time = 0.6
Courant Number mean: 0.0974263 max: 0.614972
smoothSolver: Solving for Ux, Initial residual = 0.0010079, Final residual = 3.57148e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00179787, Final residual = 2.45328e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00137297, Final residual = 0.000126485, No Iterations 4
time step continuity errors : sum local = 3.10814e-08, global = 2.58456e-09, cumulative = 3.81648e-06
GAMG: Solving for p, Initial residual = 0.000284755, Final residual = 9.22233e-07, No Iterations 16
time step continuity errors : sum local = 2.26639e-10, global = 2.63573e-11, cumulative = 3.8165e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107028, Final residual = 2.20267e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00361594, Final residual = 7.67689e-06, No Iterations 4
ExecutionTime = 6.76 s ClockTime = 7 s
Time = 0.6025
Courant Number mean: 0.0974951 max: 0.615008
smoothSolver: Solving for Ux, Initial residual = 0.00100793, Final residual = 3.55609e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00179377, Final residual = 2.43169e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00130246, Final residual = 0.000126045, No Iterations 4
time step continuity errors : sum local = 3.09768e-08, global = 2.64042e-09, cumulative = 3.81914e-06
GAMG: Solving for p, Initial residual = 0.000282558, Final residual = 9.3818e-07, No Iterations 16
time step continuity errors : sum local = 2.3057e-10, global = 2.18624e-11, cumulative = 3.81916e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106818, Final residual = 2.19693e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00360463, Final residual = 7.65191e-06, No Iterations 4
ExecutionTime = 6.78 s ClockTime = 7 s
Time = 0.605
Courant Number mean: 0.097564 max: 0.615043
smoothSolver: Solving for Ux, Initial residual = 0.00100792, Final residual = 3.53647e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00178958, Final residual = 2.40919e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0013689, Final residual = 0.000127736, No Iterations 4
time step continuity errors : sum local = 3.13909e-08, global = 2.6486e-09, cumulative = 3.82181e-06
GAMG: Solving for p, Initial residual = 0.000282969, Final residual = 9.29446e-07, No Iterations 16
time step continuity errors : sum local = 2.28394e-10, global = 2.5382e-11, cumulative = 3.82184e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106595, Final residual = 2.18428e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00359526, Final residual = 7.62703e-06, No Iterations 4
ExecutionTime = 6.81 s ClockTime = 7 s
Time = 0.6075
Courant Number mean: 0.097633 max: 0.615077
smoothSolver: Solving for Ux, Initial residual = 0.00100802, Final residual = 3.52055e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00178458, Final residual = 2.38766e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00133423, Final residual = 0.000127116, No Iterations 4
time step continuity errors : sum local = 3.12359e-08, global = 2.65311e-09, cumulative = 3.82449e-06
GAMG: Solving for p, Initial residual = 0.000280265, Final residual = 9.32234e-07, No Iterations 16
time step continuity errors : sum local = 2.29069e-10, global = 2.18822e-11, cumulative = 3.82451e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106375, Final residual = 2.17352e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00358709, Final residual = 7.60419e-06, No Iterations 4
ExecutionTime = 6.84 s ClockTime = 7 s
Time = 0.61
Courant Number mean: 0.097702 max: 0.615111
smoothSolver: Solving for Ux, Initial residual = 0.00100812, Final residual = 3.50211e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00177974, Final residual = 2.36623e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00141028, Final residual = 0.000127165, No Iterations 4
time step continuity errors : sum local = 3.12459e-08, global = 2.70785e-09, cumulative = 3.82722e-06
GAMG: Solving for p, Initial residual = 0.000284606, Final residual = 9.41332e-07, No Iterations 16
time step continuity errors : sum local = 2.31288e-10, global = 2.42905e-11, cumulative = 3.82724e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106147, Final residual = 2.16477e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00357917, Final residual = 7.582e-06, No Iterations 4
ExecutionTime = 6.86 s ClockTime = 7 s
Time = 0.6125
Courant Number mean: 0.097771 max: 0.615145
smoothSolver: Solving for Ux, Initial residual = 0.00100817, Final residual = 3.48545e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00177509, Final residual = 2.34499e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00141372, Final residual = 0.000128819, No Iterations 4
time step continuity errors : sum local = 3.16509e-08, global = 2.69984e-09, cumulative = 3.82994e-06
GAMG: Solving for p, Initial residual = 0.00028029, Final residual = 9.59777e-07, No Iterations 16
time step continuity errors : sum local = 2.35813e-10, global = 2.22676e-11, cumulative = 3.82997e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010592, Final residual = 2.15554e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00357041, Final residual = 7.56073e-06, No Iterations 4
ExecutionTime = 6.89 s ClockTime = 7 s
Time = 0.615
Courant Number mean: 0.0978401 max: 0.615177
smoothSolver: Solving for Ux, Initial residual = 0.00100819, Final residual = 3.46686e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00177015, Final residual = 2.32399e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00135122, Final residual = 0.000128013, No Iterations 4
time step continuity errors : sum local = 3.14499e-08, global = 2.73984e-09, cumulative = 3.83271e-06
GAMG: Solving for p, Initial residual = 0.000281019, Final residual = 9.37644e-07, No Iterations 16
time step continuity errors : sum local = 2.30342e-10, global = 2.2999e-11, cumulative = 3.83273e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105688, Final residual = 2.14987e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.003562, Final residual = 7.53574e-06, No Iterations 4
ExecutionTime = 6.91 s ClockTime = 7 s
Time = 0.6175
Courant Number mean: 0.0979092 max: 0.61521
smoothSolver: Solving for Ux, Initial residual = 0.00100821, Final residual = 3.44991e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00176479, Final residual = 2.30321e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00137291, Final residual = 0.000127995, No Iterations 4
time step continuity errors : sum local = 3.14402e-08, global = 2.79562e-09, cumulative = 3.83553e-06
GAMG: Solving for p, Initial residual = 0.000281326, Final residual = 9.63534e-07, No Iterations 16
time step continuity errors : sum local = 2.36655e-10, global = 2.10003e-11, cumulative = 3.83555e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105463, Final residual = 2.13767e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00355365, Final residual = 7.5122e-06, No Iterations 4
ExecutionTime = 6.94 s ClockTime = 7 s
Time = 0.62
Courant Number mean: 0.0979785 max: 0.615242
smoothSolver: Solving for Ux, Initial residual = 0.00100821, Final residual = 3.43164e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00176087, Final residual = 9.93816e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00140317, Final residual = 0.000138152, No Iterations 4
time step continuity errors : sum local = 3.39309e-08, global = 2.80849e-09, cumulative = 3.83835e-06
GAMG: Solving for p, Initial residual = 0.000291652, Final residual = 6.86568e-07, No Iterations 18
time step continuity errors : sum local = 1.68618e-10, global = 1.47354e-11, cumulative = 3.83837e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105299, Final residual = 2.12926e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00354457, Final residual = 7.489e-06, No Iterations 4
ExecutionTime = 6.96 s ClockTime = 7 s
Time = 0.6225
Courant Number mean: 0.0980478 max: 0.615273
smoothSolver: Solving for Ux, Initial residual = 0.00100824, Final residual = 3.41611e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00175808, Final residual = 9.87658e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00134494, Final residual = 8.39116e-05, No Iterations 5
time step continuity errors : sum local = 2.06094e-08, global = -2.0186e-09, cumulative = 3.83635e-06
GAMG: Solving for p, Initial residual = 0.000267268, Final residual = 6.25498e-07, No Iterations 17
time step continuity errors : sum local = 1.53631e-10, global = 7.59438e-12, cumulative = 3.83636e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105159, Final residual = 2.12209e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00353456, Final residual = 7.46373e-06, No Iterations 4
ExecutionTime = 6.99 s ClockTime = 7 s
Time = 0.625
Courant Number mean: 0.0981171 max: 0.615304
smoothSolver: Solving for Ux, Initial residual = 0.00100831, Final residual = 3.40063e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00175449, Final residual = 9.8092e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00139435, Final residual = 0.000135936, No Iterations 4
time step continuity errors : sum local = 3.33894e-08, global = 3.34625e-09, cumulative = 3.8397e-06
GAMG: Solving for p, Initial residual = 0.000287437, Final residual = 6.81838e-07, No Iterations 18
time step continuity errors : sum local = 1.67481e-10, global = 1.39792e-11, cumulative = 3.83972e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105017, Final residual = 2.11264e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00352429, Final residual = 7.43867e-06, No Iterations 4
ExecutionTime = 7.01 s ClockTime = 7 s
Time = 0.6275
Courant Number mean: 0.0981862 max: 0.615335
smoothSolver: Solving for Ux, Initial residual = 0.00100828, Final residual = 3.38109e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00175096, Final residual = 9.73497e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00137043, Final residual = 8.41309e-05, No Iterations 5
time step continuity errors : sum local = 2.06655e-08, global = -1.99249e-09, cumulative = 3.83773e-06
GAMG: Solving for p, Initial residual = 0.000269512, Final residual = 6.34696e-07, No Iterations 17
time step continuity errors : sum local = 1.55908e-10, global = 8.60644e-12, cumulative = 3.83774e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104868, Final residual = 2.10536e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00351387, Final residual = 7.41003e-06, No Iterations 4
ExecutionTime = 7.04 s ClockTime = 7 s
Time = 0.63
Courant Number mean: 0.0982553 max: 0.615365
smoothSolver: Solving for Ux, Initial residual = 0.00100842, Final residual = 3.37191e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00174626, Final residual = 9.67301e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00135433, Final residual = 0.000135339, No Iterations 4
time step continuity errors : sum local = 3.3246e-08, global = 3.3645e-09, cumulative = 3.8411e-06
GAMG: Solving for p, Initial residual = 0.000285161, Final residual = 6.43789e-07, No Iterations 18
time step continuity errors : sum local = 1.58146e-10, global = 1.25309e-11, cumulative = 3.84111e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104714, Final residual = 2.10135e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00350317, Final residual = 7.38436e-06, No Iterations 4
ExecutionTime = 7.06 s ClockTime = 7 s
Time = 0.6325
Courant Number mean: 0.0983242 max: 0.615395
smoothSolver: Solving for Ux, Initial residual = 0.00100833, Final residual = 3.3477e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0017426, Final residual = 9.59882e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129292, Final residual = 8.30863e-05, No Iterations 5
time step continuity errors : sum local = 2.04092e-08, global = -1.96399e-09, cumulative = 3.83915e-06
GAMG: Solving for p, Initial residual = 0.000263432, Final residual = 6.51717e-07, No Iterations 17
time step continuity errors : sum local = 1.60091e-10, global = 9.55137e-12, cumulative = 3.83916e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104549, Final residual = 2.0882e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00349214, Final residual = 7.36187e-06, No Iterations 4
ExecutionTime = 7.08 s ClockTime = 7 s
Time = 0.635
Courant Number mean: 0.0983928 max: 0.615424
smoothSolver: Solving for Ux, Initial residual = 0.00100845, Final residual = 3.34174e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00173886, Final residual = 9.53747e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00132126, Final residual = 9.61622e-05, No Iterations 5
time step continuity errors : sum local = 2.36251e-08, global = -2.60086e-09, cumulative = 3.83656e-06
GAMG: Solving for p, Initial residual = 0.000273044, Final residual = 6.21029e-07, No Iterations 17
time step continuity errors : sum local = 1.52583e-10, global = 6.8407e-12, cumulative = 3.83656e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104374, Final residual = 2.07927e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0034811, Final residual = 7.33765e-06, No Iterations 4
ExecutionTime = 7.11 s ClockTime = 7 s
Time = 0.6375
Courant Number mean: 0.0984612 max: 0.615453
smoothSolver: Solving for Ux, Initial residual = 0.00100835, Final residual = 3.31755e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00173457, Final residual = 9.46927e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129823, Final residual = 9.65522e-05, No Iterations 5
time step continuity errors : sum local = 2.37234e-08, global = -2.59646e-09, cumulative = 3.83397e-06
GAMG: Solving for p, Initial residual = 0.000268322, Final residual = 6.52249e-07, No Iterations 17
time step continuity errors : sum local = 1.60269e-10, global = 8.16513e-12, cumulative = 3.83398e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104187, Final residual = 2.07232e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00347256, Final residual = 7.31346e-06, No Iterations 4
ExecutionTime = 7.13 s ClockTime = 7 s
Time = 0.64
Courant Number mean: 0.0985295 max: 0.615482
smoothSolver: Solving for Ux, Initial residual = 0.00100835, Final residual = 3.30745e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00173052, Final residual = 9.40223e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00130964, Final residual = 9.66445e-05, No Iterations 5
time step continuity errors : sum local = 2.37478e-08, global = -2.63207e-09, cumulative = 3.83134e-06
GAMG: Solving for p, Initial residual = 0.000271002, Final residual = 6.17661e-07, No Iterations 17
time step continuity errors : sum local = 1.51771e-10, global = 6.91791e-12, cumulative = 3.83135e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103982, Final residual = 2.06257e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00346526, Final residual = 7.29394e-06, No Iterations 4
ExecutionTime = 7.15 s ClockTime = 7 s
Time = 0.6425
Courant Number mean: 0.0985977 max: 0.61551
smoothSolver: Solving for Ux, Initial residual = 0.00100831, Final residual = 3.28816e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00172613, Final residual = 9.33845e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00135196, Final residual = 0.000135056, No Iterations 4
time step continuity errors : sum local = 3.31822e-08, global = 3.37067e-09, cumulative = 3.83472e-06
GAMG: Solving for p, Initial residual = 0.000277736, Final residual = 6.93191e-07, No Iterations 18
time step continuity errors : sum local = 1.70299e-10, global = 1.44525e-11, cumulative = 3.83474e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103779, Final residual = 2.05385e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00345828, Final residual = 7.27004e-06, No Iterations 4
ExecutionTime = 7.18 s ClockTime = 7 s
Time = 0.645
Courant Number mean: 0.0986657 max: 0.615538
smoothSolver: Solving for Ux, Initial residual = 0.00100825, Final residual = 3.27337e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00172097, Final residual = 9.26859e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0013034, Final residual = 8.37636e-05, No Iterations 5
time step continuity errors : sum local = 2.05765e-08, global = -1.95162e-09, cumulative = 3.83278e-06
GAMG: Solving for p, Initial residual = 0.000260378, Final residual = 6.15852e-07, No Iterations 17
time step continuity errors : sum local = 1.51274e-10, global = 7.56752e-12, cumulative = 3.83279e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103573, Final residual = 2.04777e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00345063, Final residual = 7.24791e-06, No Iterations 4
ExecutionTime = 7.2 s ClockTime = 7 s
Time = 0.6475
Courant Number mean: 0.0987333 max: 0.615566
smoothSolver: Solving for Ux, Initial residual = 0.00100825, Final residual = 3.26096e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00171473, Final residual = 9.21027e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00127847, Final residual = 9.60193e-05, No Iterations 5
time step continuity errors : sum local = 2.35866e-08, global = -2.56779e-09, cumulative = 3.83022e-06
GAMG: Solving for p, Initial residual = 0.000267432, Final residual = 6.12402e-07, No Iterations 17
time step continuity errors : sum local = 1.50431e-10, global = 6.76906e-12, cumulative = 3.83023e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103355, Final residual = 2.03871e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00344256, Final residual = 7.22672e-06, No Iterations 4
ExecutionTime = 7.23 s ClockTime = 7 s
Time = 0.65
Courant Number mean: 0.0988008 max: 0.615593
smoothSolver: Solving for Ux, Initial residual = 0.00100815, Final residual = 3.24192e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00170915, Final residual = 9.14657e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00133187, Final residual = 9.65674e-05, No Iterations 5
time step continuity errors : sum local = 2.37226e-08, global = -2.59052e-09, cumulative = 3.82764e-06
GAMG: Solving for p, Initial residual = 0.00026789, Final residual = 6.3926e-07, No Iterations 17
time step continuity errors : sum local = 1.57048e-10, global = 7.72574e-12, cumulative = 3.82765e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103148, Final residual = 2.03069e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0034345, Final residual = 7.20517e-06, No Iterations 4
ExecutionTime = 7.26 s ClockTime = 7 s
Time = 0.6525
Courant Number mean: 0.0988681 max: 0.615621
smoothSolver: Solving for Ux, Initial residual = 0.0010081, Final residual = 3.22878e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00170414, Final residual = 9.08659e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00132866, Final residual = 9.61688e-05, No Iterations 5
time step continuity errors : sum local = 2.36283e-08, global = -2.59693e-09, cumulative = 3.82505e-06
GAMG: Solving for p, Initial residual = 0.00026874, Final residual = 6.33677e-07, No Iterations 17
time step continuity errors : sum local = 1.55702e-10, global = 7.3987e-12, cumulative = 3.82506e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102989, Final residual = 2.02339e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00342536, Final residual = 7.18283e-06, No Iterations 4
ExecutionTime = 7.29 s ClockTime = 7 s
Time = 0.655
Courant Number mean: 0.0989352 max: 0.615647
smoothSolver: Solving for Ux, Initial residual = 0.00100805, Final residual = 3.21254e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00170063, Final residual = 9.02596e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00131815, Final residual = 9.54319e-05, No Iterations 5
time step continuity errors : sum local = 2.34494e-08, global = -2.55314e-09, cumulative = 3.8225e-06
GAMG: Solving for p, Initial residual = 0.000267112, Final residual = 6.25264e-07, No Iterations 17
time step continuity errors : sum local = 1.53639e-10, global = 7.24387e-12, cumulative = 3.82251e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010286, Final residual = 2.01524e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00341551, Final residual = 7.15693e-06, No Iterations 4
ExecutionTime = 7.32 s ClockTime = 7 s
Time = 0.6575
Courant Number mean: 0.0990021 max: 0.615674
smoothSolver: Solving for Ux, Initial residual = 0.00100808, Final residual = 3.19893e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00169757, Final residual = 8.96474e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0012959, Final residual = 9.61991e-05, No Iterations 5
time step continuity errors : sum local = 2.36383e-08, global = -2.56683e-09, cumulative = 3.81995e-06
GAMG: Solving for p, Initial residual = 0.000266831, Final residual = 6.2582e-07, No Iterations 17
time step continuity errors : sum local = 1.53777e-10, global = 7.24734e-12, cumulative = 3.81995e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102714, Final residual = 2.01105e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00340549, Final residual = 7.13226e-06, No Iterations 4
ExecutionTime = 7.34 s ClockTime = 7 s
Time = 0.66
Courant Number mean: 0.099069 max: 0.6157
smoothSolver: Solving for Ux, Initial residual = 0.00100813, Final residual = 3.18447e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00169476, Final residual = 8.90479e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00136439, Final residual = 0.000135171, No Iterations 4
time step continuity errors : sum local = 3.32162e-08, global = 3.32686e-09, cumulative = 3.82328e-06
GAMG: Solving for p, Initial residual = 0.000278954, Final residual = 6.83731e-07, No Iterations 18
time step continuity errors : sum local = 1.68025e-10, global = 1.32648e-11, cumulative = 3.82329e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010256, Final residual = 2.00508e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0033953, Final residual = 7.10786e-06, No Iterations 4
ExecutionTime = 7.37 s ClockTime = 7 s
Time = 0.6625
Courant Number mean: 0.0991369 max: 0.615726
smoothSolver: Solving for Ux, Initial residual = 0.00100814, Final residual = 3.16889e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00169144, Final residual = 8.84204e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00135007, Final residual = 8.29023e-05, No Iterations 5
time step continuity errors : sum local = 2.03744e-08, global = -1.93797e-09, cumulative = 3.82135e-06
GAMG: Solving for p, Initial residual = 0.000264372, Final residual = 6.24989e-07, No Iterations 17
time step continuity errors : sum local = 1.53615e-10, global = 7.88689e-12, cumulative = 3.82136e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102396, Final residual = 1.99783e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00338508, Final residual = 7.08424e-06, No Iterations 4
ExecutionTime = 7.39 s ClockTime = 7 s
Time = 0.665
Courant Number mean: 0.0992053 max: 0.615752
smoothSolver: Solving for Ux, Initial residual = 0.00100824, Final residual = 3.1594e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00168761, Final residual = 8.78765e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142413, Final residual = 0.00013424, No Iterations 4
time step continuity errors : sum local = 3.29938e-08, global = 3.25817e-09, cumulative = 3.82462e-06
GAMG: Solving for p, Initial residual = 0.000284245, Final residual = 6.31839e-07, No Iterations 18
time step continuity errors : sum local = 1.55288e-10, global = 1.17189e-11, cumulative = 3.82463e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102224, Final residual = 1.99036e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00337499, Final residual = 7.06378e-06, No Iterations 4
ExecutionTime = 7.42 s ClockTime = 7 s
Time = 0.6675
Courant Number mean: 0.0992743 max: 0.615778
smoothSolver: Solving for Ux, Initial residual = 0.00100819, Final residual = 3.13887e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00168353, Final residual = 8.72333e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00139462, Final residual = 0.000135847, No Iterations 4
time step continuity errors : sum local = 3.33829e-08, global = 2.75749e-09, cumulative = 3.82739e-06
GAMG: Solving for p, Initial residual = 0.000290266, Final residual = 6.64208e-07, No Iterations 18
time step continuity errors : sum local = 1.63215e-10, global = 1.71262e-11, cumulative = 3.82741e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102049, Final residual = 1.98126e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00336485, Final residual = 7.0414e-06, No Iterations 4
ExecutionTime = 7.44 s ClockTime = 8 s
Time = 0.67
Courant Number mean: 0.0993434 max: 0.615803
smoothSolver: Solving for Ux, Initial residual = 0.00100828, Final residual = 3.13281e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00168063, Final residual = 8.67034e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00134902, Final residual = 0.000134177, No Iterations 4
time step continuity errors : sum local = 3.29703e-08, global = 2.7325e-09, cumulative = 3.83014e-06
GAMG: Solving for p, Initial residual = 0.000285899, Final residual = 5.63116e-07, No Iterations 18
time step continuity errors : sum local = 1.38365e-10, global = 8.68395e-12, cumulative = 3.83015e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101875, Final residual = 1.97281e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00335654, Final residual = 7.01737e-06, No Iterations 4
ExecutionTime = 7.47 s ClockTime = 8 s
Time = 0.6725
Courant Number mean: 0.0994125 max: 0.615828
smoothSolver: Solving for Ux, Initial residual = 0.0010082, Final residual = 3.11204e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00167775, Final residual = 8.61084e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00131727, Final residual = 8.36461e-05, No Iterations 5
time step continuity errors : sum local = 2.05522e-08, global = -1.96406e-09, cumulative = 3.82818e-06
GAMG: Solving for p, Initial residual = 0.0002571, Final residual = 5.81231e-07, No Iterations 17
time step continuity errors : sum local = 1.42808e-10, global = 6.77637e-12, cumulative = 3.82819e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101696, Final residual = 1.96393e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00334934, Final residual = 6.99744e-06, No Iterations 4
ExecutionTime = 7.49 s ClockTime = 8 s
Time = 0.675
Courant Number mean: 0.0994817 max: 0.615852
smoothSolver: Solving for Ux, Initial residual = 0.00100825, Final residual = 3.10484e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00167469, Final residual = 8.55651e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00133604, Final residual = 0.000131811, No Iterations 4
time step continuity errors : sum local = 3.23885e-08, global = 3.22741e-09, cumulative = 3.83142e-06
GAMG: Solving for p, Initial residual = 0.000276586, Final residual = 6.11969e-07, No Iterations 18
time step continuity errors : sum local = 1.5038e-10, global = 1.14707e-11, cumulative = 3.83143e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101512, Final residual = 1.95987e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00334283, Final residual = 6.9766e-06, No Iterations 4
ExecutionTime = 7.52 s ClockTime = 8 s
Time = 0.6775
Courant Number mean: 0.0995511 max: 0.615876
smoothSolver: Solving for Ux, Initial residual = 0.00100814, Final residual = 3.08304e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00167099, Final residual = 8.49505e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00132581, Final residual = 8.43923e-05, No Iterations 5
time step continuity errors : sum local = 2.07366e-08, global = -1.95283e-09, cumulative = 3.82948e-06
GAMG: Solving for p, Initial residual = 0.000260712, Final residual = 4.88411e-07, No Iterations 17
time step continuity errors : sum local = 1.20017e-10, global = 4.4385e-12, cumulative = 3.82948e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101349, Final residual = 1.9521e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00333602, Final residual = 6.95428e-06, No Iterations 4
ExecutionTime = 7.54 s ClockTime = 8 s
Time = 0.68
Courant Number mean: 0.0996205 max: 0.6159
smoothSolver: Solving for Ux, Initial residual = 0.00100819, Final residual = 3.07335e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00166678, Final residual = 8.44188e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00141572, Final residual = 0.0001355, No Iterations 4
time step continuity errors : sum local = 3.32975e-08, global = 3.23968e-09, cumulative = 3.83272e-06
GAMG: Solving for p, Initial residual = 0.000271682, Final residual = 6.30611e-07, No Iterations 18
time step continuity errors : sum local = 1.54978e-10, global = 1.24156e-11, cumulative = 3.83273e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101173, Final residual = 1.94546e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00332879, Final residual = 6.93357e-06, No Iterations 4
ExecutionTime = 7.56 s ClockTime = 8 s
Time = 0.6825
Courant Number mean: 0.09969 max: 0.615924
smoothSolver: Solving for Ux, Initial residual = 0.00100819, Final residual = 3.05896e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00166181, Final residual = 8.38691e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00134206, Final residual = 0.000133915, No Iterations 4
time step continuity errors : sum local = 3.29125e-08, global = 2.63453e-09, cumulative = 3.83537e-06
GAMG: Solving for p, Initial residual = 0.000276308, Final residual = 6.17513e-07, No Iterations 18
time step continuity errors : sum local = 1.51784e-10, global = 1.22458e-11, cumulative = 3.83538e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100983, Final residual = 1.93899e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00332087, Final residual = 6.91207e-06, No Iterations 4
ExecutionTime = 7.59 s ClockTime = 8 s
Time = 0.685
Courant Number mean: 0.0997596 max: 0.615947
smoothSolver: Solving for Ux, Initial residual = 0.00100822, Final residual = 3.0481e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00165612, Final residual = 8.33437e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00132724, Final residual = 8.31325e-05, No Iterations 5
time step continuity errors : sum local = 2.04346e-08, global = -1.95842e-09, cumulative = 3.83342e-06
GAMG: Solving for p, Initial residual = 0.000253225, Final residual = 5.32293e-07, No Iterations 17
time step continuity errors : sum local = 1.30843e-10, global = 5.52228e-12, cumulative = 3.83343e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100833, Final residual = 1.93137e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00331234, Final residual = 6.88929e-06, No Iterations 4
ExecutionTime = 7.61 s ClockTime = 8 s
Time = 0.6875
Courant Number mean: 0.0998295 max: 0.61597
smoothSolver: Solving for Ux, Initial residual = 0.00100819, Final residual = 3.0332e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00165096, Final residual = 8.28373e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00131585, Final residual = 9.65316e-05, No Iterations 5
time step continuity errors : sum local = 2.37293e-08, global = -2.61044e-09, cumulative = 3.83082e-06
GAMG: Solving for p, Initial residual = 0.000262352, Final residual = 5.68968e-07, No Iterations 17
time step continuity errors : sum local = 1.39862e-10, global = 6.29803e-12, cumulative = 3.83082e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100706, Final residual = 1.92564e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00330323, Final residual = 6.86749e-06, No Iterations 4
ExecutionTime = 7.63 s ClockTime = 8 s
Time = 0.69
Courant Number mean: 0.0998996 max: 0.615992
smoothSolver: Solving for Ux, Initial residual = 0.00100815, Final residual = 3.01989e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00164739, Final residual = 8.23158e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00144003, Final residual = 0.000134283, No Iterations 4
time step continuity errors : sum local = 3.30066e-08, global = 3.268e-09, cumulative = 3.83409e-06
GAMG: Solving for p, Initial residual = 0.000272558, Final residual = 6.18885e-07, No Iterations 18
time step continuity errors : sum local = 1.52114e-10, global = 1.30306e-11, cumulative = 3.8341e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100578, Final residual = 1.91944e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00329377, Final residual = 6.84321e-06, No Iterations 4
ExecutionTime = 7.66 s ClockTime = 8 s
Time = 0.6925
Courant Number mean: 0.0999701 max: 0.616015
smoothSolver: Solving for Ux, Initial residual = 0.00100812, Final residual = 3.00546e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00164411, Final residual = 8.17828e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00137905, Final residual = 0.000134713, No Iterations 4
time step continuity errors : sum local = 3.31105e-08, global = 2.75455e-09, cumulative = 3.83686e-06
GAMG: Solving for p, Initial residual = 0.000281477, Final residual = 9.50322e-07, No Iterations 16
time step continuity errors : sum local = 2.33587e-10, global = 2.08674e-11, cumulative = 3.83688e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100443, Final residual = 1.91573e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00328418, Final residual = 6.82094e-06, No Iterations 4
ExecutionTime = 7.68 s ClockTime = 8 s
Time = 0.695
Courant Number mean: 0.100042 max: 0.616036
smoothSolver: Solving for Ux, Initial residual = 0.00100821, Final residual = 2.99724e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00164096, Final residual = 8.13025e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00134917, Final residual = 0.000133518, No Iterations 4
time step continuity errors : sum local = 3.28204e-08, global = 2.90344e-09, cumulative = 3.83978e-06
GAMG: Solving for p, Initial residual = 0.000279046, Final residual = 9.81811e-07, No Iterations 16
time step continuity errors : sum local = 2.41351e-10, global = 1.57264e-11, cumulative = 3.8398e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100315, Final residual = 1.91003e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0032747, Final residual = 6.7974e-06, No Iterations 4
ExecutionTime = 7.7 s ClockTime = 8 s
Time = 0.6975
Courant Number mean: 0.100114 max: 0.616058
smoothSolver: Solving for Ux, Initial residual = 0.00100819, Final residual = 2.98107e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00163774, Final residual = 8.0767e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129086, Final residual = 8.36844e-05, No Iterations 5
time step continuity errors : sum local = 2.05721e-08, global = -2.00663e-09, cumulative = 3.83779e-06
GAMG: Solving for p, Initial residual = 0.000252781, Final residual = 9.9044e-07, No Iterations 15
time step continuity errors : sum local = 2.43484e-10, global = 1.06028e-11, cumulative = 3.8378e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100198, Final residual = 1.90596e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00326499, Final residual = 6.77602e-06, No Iterations 4
ExecutionTime = 7.72 s ClockTime = 8 s
Time = 0.7
Courant Number mean: 0.100187 max: 0.616079
smoothSolver: Solving for Ux, Initial residual = 0.00100823, Final residual = 2.97236e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0016338, Final residual = 8.02856e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00131499, Final residual = 9.67997e-05, No Iterations 5
time step continuity errors : sum local = 2.37999e-08, global = -2.65681e-09, cumulative = 3.83515e-06
GAMG: Solving for p, Initial residual = 0.000264994, Final residual = 5.10463e-07, No Iterations 17
time step continuity errors : sum local = 1.25513e-10, global = 5.02526e-12, cumulative = 3.83515e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100075, Final residual = 1.89933e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00325536, Final residual = 6.75488e-06, No Iterations 4
ExecutionTime = 7.78 s ClockTime = 8 s
Time = 0.7025
Courant Number mean: 0.10026 max: 0.6161
smoothSolver: Solving for Ux, Initial residual = 0.00100819, Final residual = 2.95594e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00162944, Final residual = 7.97895e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0013403, Final residual = 0.000133688, No Iterations 4
time step continuity errors : sum local = 3.28749e-08, global = 3.27037e-09, cumulative = 3.83842e-06
GAMG: Solving for p, Initial residual = 0.000270363, Final residual = 9.86581e-07, No Iterations 17
time step continuity errors : sum local = 2.42638e-10, global = -4.25032e-11, cumulative = 3.83838e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000999442, Final residual = 1.89218e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00324714, Final residual = 6.73306e-06, No Iterations 4
ExecutionTime = 7.81 s ClockTime = 8 s
Time = 0.705
Courant Number mean: 0.100332 max: 0.61612
smoothSolver: Solving for Ux, Initial residual = 0.0010082, Final residual = 2.94432e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00162537, Final residual = 7.92779e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00136943, Final residual = 0.000133184, No Iterations 4
time step continuity errors : sum local = 3.27537e-08, global = 2.68413e-09, cumulative = 3.84106e-06
GAMG: Solving for p, Initial residual = 0.000278753, Final residual = 9.06691e-07, No Iterations 16
time step continuity errors : sum local = 2.22982e-10, global = 1.48628e-11, cumulative = 3.84108e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000998033, Final residual = 1.8842e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00324008, Final residual = 6.7106e-06, No Iterations 4
ExecutionTime = 7.83 s ClockTime = 8 s
Time = 0.7075
Courant Number mean: 0.100405 max: 0.61614
smoothSolver: Solving for Ux, Initial residual = 0.0010082, Final residual = 2.93343e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00162249, Final residual = 7.88049e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00138269, Final residual = 0.000125226, No Iterations 4
time step continuity errors : sum local = 3.07973e-08, global = 2.8767e-09, cumulative = 3.84395e-06
GAMG: Solving for p, Initial residual = 0.000270666, Final residual = 9.56343e-07, No Iterations 16
time step continuity errors : sum local = 2.35207e-10, global = 1.53412e-11, cumulative = 3.84397e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000996532, Final residual = 1.8768e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00323343, Final residual = 6.69113e-06, No Iterations 4
ExecutionTime = 7.85 s ClockTime = 8 s
Time = 0.71
Courant Number mean: 0.100478 max: 0.61616
smoothSolver: Solving for Ux, Initial residual = 0.00100811, Final residual = 2.91845e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00161994, Final residual = 7.83006e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00134487, Final residual = 0.000129336, No Iterations 4
time step continuity errors : sum local = 3.18095e-08, global = 2.90554e-09, cumulative = 3.84688e-06
GAMG: Solving for p, Initial residual = 0.000270237, Final residual = 9.53569e-07, No Iterations 16
time step continuity errors : sum local = 2.34542e-10, global = 1.52566e-11, cumulative = 3.84689e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000994868, Final residual = 1.87366e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00322699, Final residual = 6.6696e-06, No Iterations 4
ExecutionTime = 7.88 s ClockTime = 8 s
Time = 0.7125
Courant Number mean: 0.100551 max: 0.616179
smoothSolver: Solving for Ux, Initial residual = 0.00100813, Final residual = 2.90832e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00161746, Final residual = 7.78321e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.001331, Final residual = 0.000125363, No Iterations 4
time step continuity errors : sum local = 3.08337e-08, global = 2.83375e-09, cumulative = 3.84972e-06
GAMG: Solving for p, Initial residual = 0.000266527, Final residual = 9.11856e-07, No Iterations 16
time step continuity errors : sum local = 2.24286e-10, global = 1.37239e-11, cumulative = 3.84974e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000993177, Final residual = 1.86779e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00322002, Final residual = 6.64895e-06, No Iterations 4
ExecutionTime = 7.9 s ClockTime = 8 s
Time = 0.715
Courant Number mean: 0.100623 max: 0.616198
smoothSolver: Solving for Ux, Initial residual = 0.00100812, Final residual = 2.89456e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00161458, Final residual = 7.73521e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00128519, Final residual = 0.000126022, No Iterations 4
time step continuity errors : sum local = 3.09969e-08, global = 2.86027e-09, cumulative = 3.8526e-06
GAMG: Solving for p, Initial residual = 0.000265024, Final residual = 9.3939e-07, No Iterations 16
time step continuity errors : sum local = 2.31078e-10, global = 1.48101e-11, cumulative = 3.85261e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000991337, Final residual = 1.8614e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00321264, Final residual = 6.62731e-06, No Iterations 4
ExecutionTime = 7.92 s ClockTime = 8 s
Time = 0.7175
Courant Number mean: 0.100696 max: 0.616217
smoothSolver: Solving for Ux, Initial residual = 0.00100812, Final residual = 2.88374e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00161135, Final residual = 7.68806e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00130912, Final residual = 0.000126666, No Iterations 4
time step continuity errors : sum local = 3.11572e-08, global = 2.83446e-09, cumulative = 3.85545e-06
GAMG: Solving for p, Initial residual = 0.000267757, Final residual = 9.03829e-07, No Iterations 16
time step continuity errors : sum local = 2.22336e-10, global = 1.3422e-11, cumulative = 3.85546e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000989572, Final residual = 1.85737e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00320444, Final residual = 6.60515e-06, No Iterations 4
ExecutionTime = 7.95 s ClockTime = 8 s
Time = 0.72
Courant Number mean: 0.100768 max: 0.616235
smoothSolver: Solving for Ux, Initial residual = 0.00100809, Final residual = 2.87059e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00160729, Final residual = 7.64164e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00130183, Final residual = 0.000125803, No Iterations 4
time step continuity errors : sum local = 3.09475e-08, global = 2.81241e-09, cumulative = 3.85827e-06
GAMG: Solving for p, Initial residual = 0.000267248, Final residual = 9.23508e-07, No Iterations 16
time step continuity errors : sum local = 2.27205e-10, global = 1.42435e-11, cumulative = 3.85829e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000988316, Final residual = 1.85435e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00319612, Final residual = 6.58441e-06, No Iterations 4
ExecutionTime = 7.97 s ClockTime = 8 s
Time = 0.7225
Courant Number mean: 0.100841 max: 0.616254
smoothSolver: Solving for Ux, Initial residual = 0.00100803, Final residual = 2.85948e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00160356, Final residual = 7.5968e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00132742, Final residual = 0.000126982, No Iterations 4
time step continuity errors : sum local = 3.12431e-08, global = 2.88284e-09, cumulative = 3.86117e-06
GAMG: Solving for p, Initial residual = 0.000268018, Final residual = 8.99281e-07, No Iterations 16
time step continuity errors : sum local = 2.21298e-10, global = 1.31822e-11, cumulative = 3.86118e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000987106, Final residual = 1.8465e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0031875, Final residual = 6.5632e-06, No Iterations 4
ExecutionTime = 8 s ClockTime = 8 s
Time = 0.725
Courant Number mean: 0.100913 max: 0.616272
smoothSolver: Solving for Ux, Initial residual = 0.00100796, Final residual = 2.84735e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00160041, Final residual = 7.55181e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00130719, Final residual = 0.000127243, No Iterations 4
time step continuity errors : sum local = 3.13153e-08, global = 2.85171e-09, cumulative = 3.86404e-06
GAMG: Solving for p, Initial residual = 0.000269892, Final residual = 9.05026e-07, No Iterations 16
time step continuity errors : sum local = 2.22768e-10, global = 1.35721e-11, cumulative = 3.86405e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000985722, Final residual = 1.83808e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00317869, Final residual = 6.54185e-06, No Iterations 4
ExecutionTime = 8.02 s ClockTime = 8 s
Time = 0.7275
Courant Number mean: 0.100985 max: 0.616289
smoothSolver: Solving for Ux, Initial residual = 0.00100791, Final residual = 2.83672e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00159725, Final residual = 7.50716e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00128896, Final residual = 0.000126563, No Iterations 4
time step continuity errors : sum local = 3.11528e-08, global = 2.86523e-09, cumulative = 3.86691e-06
GAMG: Solving for p, Initial residual = 0.000267637, Final residual = 8.93195e-07, No Iterations 16
time step continuity errors : sum local = 2.19872e-10, global = 1.333e-11, cumulative = 3.86693e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000984301, Final residual = 1.83357e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0031695, Final residual = 6.51858e-06, No Iterations 4
ExecutionTime = 8.04 s ClockTime = 8 s
Time = 0.73
Courant Number mean: 0.101057 max: 0.616307
smoothSolver: Solving for Ux, Initial residual = 0.00100786, Final residual = 2.82526e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00159412, Final residual = 7.46247e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0013629, Final residual = 0.000127032, No Iterations 4
time step continuity errors : sum local = 3.12695e-08, global = 2.87389e-09, cumulative = 3.8698e-06
GAMG: Solving for p, Initial residual = 0.000270974, Final residual = 8.92623e-07, No Iterations 16
time step continuity errors : sum local = 2.19736e-10, global = 1.32776e-11, cumulative = 3.86981e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00098281, Final residual = 1.83188e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00316053, Final residual = 6.49752e-06, No Iterations 4
ExecutionTime = 8.07 s ClockTime = 8 s
Time = 0.7325
Courant Number mean: 0.101129 max: 0.616324
smoothSolver: Solving for Ux, Initial residual = 0.00100781, Final residual = 2.8144e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00159099, Final residual = 7.41847e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00147459, Final residual = 0.000125967, No Iterations 4
time step continuity errors : sum local = 3.10096e-08, global = 2.80117e-09, cumulative = 3.87262e-06
GAMG: Solving for p, Initial residual = 0.000271909, Final residual = 8.89827e-07, No Iterations 16
time step continuity errors : sum local = 2.19072e-10, global = 1.31267e-11, cumulative = 3.87263e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000981294, Final residual = 1.82496e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00315142, Final residual = 6.47641e-06, No Iterations 4
ExecutionTime = 8.09 s ClockTime = 8 s
Time = 0.735
Courant Number mean: 0.101201 max: 0.616341
smoothSolver: Solving for Ux, Initial residual = 0.00100774, Final residual = 2.80352e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00158723, Final residual = 7.37516e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00151287, Final residual = 0.00012472, No Iterations 4
time step continuity errors : sum local = 3.06999e-08, global = 2.87953e-09, cumulative = 3.87551e-06
GAMG: Solving for p, Initial residual = 0.000271647, Final residual = 8.96735e-07, No Iterations 16
time step continuity errors : sum local = 2.20717e-10, global = 1.30861e-11, cumulative = 3.87552e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000979933, Final residual = 1.81834e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00314263, Final residual = 6.45614e-06, No Iterations 4
ExecutionTime = 8.12 s ClockTime = 8 s
Time = 0.7375
Courant Number mean: 0.101272 max: 0.616357
smoothSolver: Solving for Ux, Initial residual = 0.00100766, Final residual = 2.79243e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00158381, Final residual = 7.33178e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00144865, Final residual = 0.000124153, No Iterations 4
time step continuity errors : sum local = 3.05544e-08, global = 2.87593e-09, cumulative = 3.8784e-06
GAMG: Solving for p, Initial residual = 0.000268471, Final residual = 8.88695e-07, No Iterations 16
time step continuity errors : sum local = 2.18698e-10, global = 1.27525e-11, cumulative = 3.87841e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000978597, Final residual = 1.81215e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00313543, Final residual = 6.43531e-06, No Iterations 4
ExecutionTime = 8.14 s ClockTime = 8 s
Time = 0.74
Courant Number mean: 0.101344 max: 0.616374
smoothSolver: Solving for Ux, Initial residual = 0.00100759, Final residual = 2.78146e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00158036, Final residual = 7.2892e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142783, Final residual = 0.000125681, No Iterations 4
time step continuity errors : sum local = 3.09249e-08, global = 2.90241e-09, cumulative = 3.88131e-06
GAMG: Solving for p, Initial residual = 0.000270457, Final residual = 8.78619e-07, No Iterations 16
time step continuity errors : sum local = 2.16186e-10, global = 1.24187e-11, cumulative = 3.88133e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000977147, Final residual = 1.80689e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00312886, Final residual = 6.41444e-06, No Iterations 4
ExecutionTime = 8.16 s ClockTime = 8 s
Time = 0.7425
Courant Number mean: 0.101415 max: 0.61639
smoothSolver: Solving for Ux, Initial residual = 0.00100756, Final residual = 2.77041e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015773, Final residual = 7.24738e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00133281, Final residual = 0.00012454, No Iterations 4
time step continuity errors : sum local = 3.06412e-08, global = 2.87235e-09, cumulative = 3.8842e-06
GAMG: Solving for p, Initial residual = 0.000270201, Final residual = 8.83097e-07, No Iterations 16
time step continuity errors : sum local = 2.17278e-10, global = 1.27729e-11, cumulative = 3.88421e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000975764, Final residual = 1.80149e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00312282, Final residual = 6.39449e-06, No Iterations 4
ExecutionTime = 8.19 s ClockTime = 8 s
Time = 0.745
Courant Number mean: 0.101486 max: 0.616406
smoothSolver: Solving for Ux, Initial residual = 0.00100751, Final residual = 2.75972e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00157521, Final residual = 7.20637e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00127437, Final residual = 0.000125421, No Iterations 4
time step continuity errors : sum local = 3.08586e-08, global = 2.91514e-09, cumulative = 3.88713e-06
GAMG: Solving for p, Initial residual = 0.000269242, Final residual = 8.70323e-07, No Iterations 16
time step continuity errors : sum local = 2.14154e-10, global = 1.22563e-11, cumulative = 3.88714e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000974286, Final residual = 1.79546e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00311638, Final residual = 6.37293e-06, No Iterations 4
ExecutionTime = 8.21 s ClockTime = 8 s
Time = 0.7475
Courant Number mean: 0.101556 max: 0.616422
smoothSolver: Solving for Ux, Initial residual = 0.00100746, Final residual = 2.74841e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00157327, Final residual = 7.16474e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00127589, Final residual = 0.0001237, No Iterations 4
time step continuity errors : sum local = 3.04391e-08, global = 2.86973e-09, cumulative = 3.89001e-06
GAMG: Solving for p, Initial residual = 0.000266385, Final residual = 8.79818e-07, No Iterations 16
time step continuity errors : sum local = 2.16523e-10, global = 1.2814e-11, cumulative = 3.89002e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000972759, Final residual = 1.79321e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00310897, Final residual = 6.35083e-06, No Iterations 4
ExecutionTime = 8.23 s ClockTime = 8 s
Time = 0.75
Courant Number mean: 0.101627 max: 0.616438
smoothSolver: Solving for Ux, Initial residual = 0.00100739, Final residual = 2.73776e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00157094, Final residual = 7.12401e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00136299, Final residual = 0.000125337, No Iterations 4
time step continuity errors : sum local = 3.08487e-08, global = 2.92745e-09, cumulative = 3.89295e-06
GAMG: Solving for p, Initial residual = 0.000272087, Final residual = 8.58639e-07, No Iterations 16
time step continuity errors : sum local = 2.11371e-10, global = 1.17682e-11, cumulative = 3.89296e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000971336, Final residual = 1.7886e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0031012, Final residual = 6.33164e-06, No Iterations 4
ExecutionTime = 8.26 s ClockTime = 8 s
Time = 0.7525
Courant Number mean: 0.101697 max: 0.616454
smoothSolver: Solving for Ux, Initial residual = 0.0010073, Final residual = 2.72674e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00156841, Final residual = 7.08436e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00135261, Final residual = 0.000123955, No Iterations 4
time step continuity errors : sum local = 3.05133e-08, global = 2.92276e-09, cumulative = 3.89588e-06
GAMG: Solving for p, Initial residual = 0.000269722, Final residual = 8.68482e-07, No Iterations 16
time step continuity errors : sum local = 2.13804e-10, global = 1.21962e-11, cumulative = 3.89589e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000970072, Final residual = 1.7817e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00309297, Final residual = 6.30855e-06, No Iterations 4
ExecutionTime = 8.28 s ClockTime = 8 s
Time = 0.755
Courant Number mean: 0.101767 max: 0.616469
smoothSolver: Solving for Ux, Initial residual = 0.00100724, Final residual = 2.71593e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00156569, Final residual = 7.04513e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00133363, Final residual = 0.000126298, No Iterations 4
time step continuity errors : sum local = 3.10917e-08, global = 2.94434e-09, cumulative = 3.89884e-06
GAMG: Solving for p, Initial residual = 0.000269619, Final residual = 8.47241e-07, No Iterations 16
time step continuity errors : sum local = 2.08588e-10, global = 1.15985e-11, cumulative = 3.89885e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000969061, Final residual = 1.77584e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00308477, Final residual = 6.28567e-06, No Iterations 4
ExecutionTime = 8.3 s ClockTime = 8 s
Time = 0.7575
Courant Number mean: 0.101836 max: 0.616485
smoothSolver: Solving for Ux, Initial residual = 0.0010072, Final residual = 2.70523e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00156276, Final residual = 7.00595e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00135746, Final residual = 0.000123997, No Iterations 4
time step continuity errors : sum local = 3.05279e-08, global = 2.93832e-09, cumulative = 3.90179e-06
GAMG: Solving for p, Initial residual = 0.000268637, Final residual = 8.61794e-07, No Iterations 16
time step continuity errors : sum local = 2.12198e-10, global = 1.22306e-11, cumulative = 3.9018e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000968228, Final residual = 1.77014e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0030765, Final residual = 6.2644e-06, No Iterations 4
ExecutionTime = 8.33 s ClockTime = 8 s
Time = 0.76
Courant Number mean: 0.101906 max: 0.6165
smoothSolver: Solving for Ux, Initial residual = 0.00100714, Final residual = 2.69512e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00156063, Final residual = 6.96736e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00134735, Final residual = 0.000126588, No Iterations 4
time step continuity errors : sum local = 3.11691e-08, global = 3.01044e-09, cumulative = 3.90481e-06
GAMG: Solving for p, Initial residual = 0.000273896, Final residual = 8.29823e-07, No Iterations 16
time step continuity errors : sum local = 2.04341e-10, global = 1.07693e-11, cumulative = 3.90482e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00096721, Final residual = 1.76477e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00306816, Final residual = 6.24183e-06, No Iterations 4
ExecutionTime = 8.35 s ClockTime = 8 s
Time = 0.7625
Courant Number mean: 0.101975 max: 0.616515
smoothSolver: Solving for Ux, Initial residual = 0.00100707, Final residual = 2.68471e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155861, Final residual = 6.92926e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00134499, Final residual = 0.000126035, No Iterations 4
time step continuity errors : sum local = 3.10343e-08, global = 2.98702e-09, cumulative = 3.90781e-06
GAMG: Solving for p, Initial residual = 0.000270928, Final residual = 8.33851e-07, No Iterations 16
time step continuity errors : sum local = 2.05338e-10, global = 1.11806e-11, cumulative = 3.90782e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000966141, Final residual = 1.76021e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00305958, Final residual = 6.22258e-06, No Iterations 4
ExecutionTime = 8.37 s ClockTime = 8 s
Time = 0.765
Courant Number mean: 0.102044 max: 0.61653
smoothSolver: Solving for Ux, Initial residual = 0.001007, Final residual = 2.67496e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155675, Final residual = 6.89133e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0012967, Final residual = 0.000125345, No Iterations 4
time step continuity errors : sum local = 3.08668e-08, global = 3.00473e-09, cumulative = 3.91083e-06
GAMG: Solving for p, Initial residual = 0.000268536, Final residual = 8.42737e-07, No Iterations 16
time step continuity errors : sum local = 2.07557e-10, global = 1.15507e-11, cumulative = 3.91084e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000965054, Final residual = 1.75656e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00305122, Final residual = 6.20227e-06, No Iterations 4
ExecutionTime = 8.39 s ClockTime = 8 s
Time = 0.7675
Courant Number mean: 0.102114 max: 0.616544
smoothSolver: Solving for Ux, Initial residual = 0.00100692, Final residual = 2.66504e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155509, Final residual = 6.85363e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00128776, Final residual = 0.000124963, No Iterations 4
time step continuity errors : sum local = 3.07775e-08, global = 3.00754e-09, cumulative = 3.91384e-06
GAMG: Solving for p, Initial residual = 0.000269735, Final residual = 8.33885e-07, No Iterations 16
time step continuity errors : sum local = 2.05409e-10, global = 1.13183e-11, cumulative = 3.91386e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000963925, Final residual = 1.7508e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00304307, Final residual = 6.18288e-06, No Iterations 4
ExecutionTime = 8.42 s ClockTime = 8 s
Time = 0.77
Courant Number mean: 0.102187 max: 0.616559
smoothSolver: Solving for Ux, Initial residual = 0.00100685, Final residual = 2.65541e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155346, Final residual = 6.81606e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00131061, Final residual = 0.000125369, No Iterations 4
time step continuity errors : sum local = 3.0883e-08, global = 3.03173e-09, cumulative = 3.91689e-06
GAMG: Solving for p, Initial residual = 0.000270385, Final residual = 8.3218e-07, No Iterations 16
time step continuity errors : sum local = 2.05028e-10, global = 1.12876e-11, cumulative = 3.9169e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000962688, Final residual = 1.74548e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00303601, Final residual = 6.16354e-06, No Iterations 4
ExecutionTime = 8.44 s ClockTime = 9 s
Time = 0.7725
Courant Number mean: 0.102262 max: 0.616574
smoothSolver: Solving for Ux, Initial residual = 0.00100675, Final residual = 2.64547e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155178, Final residual = 6.77852e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00127642, Final residual = 0.000125428, No Iterations 4
time step continuity errors : sum local = 3.09038e-08, global = 3.03903e-09, cumulative = 3.91994e-06
GAMG: Solving for p, Initial residual = 0.000268199, Final residual = 8.1964e-07, No Iterations 16
time step continuity errors : sum local = 2.01981e-10, global = 1.09658e-11, cumulative = 3.91995e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000961494, Final residual = 1.74303e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00302988, Final residual = 6.14278e-06, No Iterations 4
ExecutionTime = 8.46 s ClockTime = 9 s
Time = 0.775
Courant Number mean: 0.102339 max: 0.616588
smoothSolver: Solving for Ux, Initial residual = 0.00100665, Final residual = 2.63553e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154984, Final residual = 6.74169e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00130327, Final residual = 0.000125517, No Iterations 4
time step continuity errors : sum local = 3.0933e-08, global = 3.05266e-09, cumulative = 3.923e-06
GAMG: Solving for p, Initial residual = 0.00026907, Final residual = 8.12734e-07, No Iterations 16
time step continuity errors : sum local = 2.0033e-10, global = 1.0932e-11, cumulative = 3.92301e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000960191, Final residual = 1.7409e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00302395, Final residual = 6.12482e-06, No Iterations 4
ExecutionTime = 8.48 s ClockTime = 9 s
Time = 0.7775
Courant Number mean: 0.102416 max: 0.616602
smoothSolver: Solving for Ux, Initial residual = 0.00100655, Final residual = 2.62583e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154731, Final residual = 6.70544e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00133856, Final residual = 0.000126209, No Iterations 4
time step continuity errors : sum local = 3.11128e-08, global = 3.06547e-09, cumulative = 3.92608e-06
GAMG: Solving for p, Initial residual = 0.000271071, Final residual = 7.99231e-07, No Iterations 16
time step continuity errors : sum local = 1.97071e-10, global = 1.05122e-11, cumulative = 3.92609e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000958854, Final residual = 1.73812e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00301767, Final residual = 6.10691e-06, No Iterations 4
ExecutionTime = 8.5 s ClockTime = 9 s
Time = 0.78
Courant Number mean: 0.102493 max: 0.616616
smoothSolver: Solving for Ux, Initial residual = 0.00100646, Final residual = 2.61603e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154525, Final residual = 6.66967e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00143462, Final residual = 0.00012826, No Iterations 4
time step continuity errors : sum local = 3.16301e-08, global = 3.07701e-09, cumulative = 3.92917e-06
GAMG: Solving for p, Initial residual = 0.000276464, Final residual = 7.92754e-07, No Iterations 16
time step continuity errors : sum local = 1.95548e-10, global = 1.05228e-11, cumulative = 3.92918e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000957498, Final residual = 1.73302e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00301117, Final residual = 6.08229e-06, No Iterations 4
ExecutionTime = 8.53 s ClockTime = 9 s
Time = 0.7825
Courant Number mean: 0.102571 max: 0.61663
smoothSolver: Solving for Ux, Initial residual = 0.00100637, Final residual = 2.6065e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154284, Final residual = 6.63462e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00139084, Final residual = 0.000124049, No Iterations 4
time step continuity errors : sum local = 3.06008e-08, global = 2.96414e-09, cumulative = 3.93214e-06
GAMG: Solving for p, Initial residual = 0.000278483, Final residual = 7.16526e-07, No Iterations 16
time step continuity errors : sum local = 1.76784e-10, global = 7.59401e-12, cumulative = 3.93215e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00095602, Final residual = 1.73013e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00300388, Final residual = 6.06218e-06, No Iterations 4
ExecutionTime = 8.56 s ClockTime = 9 s
Time = 0.785
Courant Number mean: 0.102648 max: 0.616644
smoothSolver: Solving for Ux, Initial residual = 0.0010063, Final residual = 2.59676e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154096, Final residual = 6.6014e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00137715, Final residual = 0.000126789, No Iterations 4
time step continuity errors : sum local = 3.12823e-08, global = 3.10199e-09, cumulative = 3.93525e-06
GAMG: Solving for p, Initial residual = 0.000271644, Final residual = 7.82862e-07, No Iterations 16
time step continuity errors : sum local = 1.93175e-10, global = 1.01332e-11, cumulative = 3.93526e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000954508, Final residual = 1.72714e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0029965, Final residual = 6.04142e-06, No Iterations 4
ExecutionTime = 8.58 s ClockTime = 9 s
Time = 0.7875
Courant Number mean: 0.102725 max: 0.616657
smoothSolver: Solving for Ux, Initial residual = 0.0010062, Final residual = 2.58674e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00153826, Final residual = 6.56704e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00141812, Final residual = 0.000126534, No Iterations 4
time step continuity errors : sum local = 3.12231e-08, global = 3.11891e-09, cumulative = 3.93838e-06
GAMG: Solving for p, Initial residual = 0.000272121, Final residual = 7.85863e-07, No Iterations 16
time step continuity errors : sum local = 1.93942e-10, global = 1.02804e-11, cumulative = 3.93839e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000953233, Final residual = 1.71954e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00298882, Final residual = 6.02042e-06, No Iterations 4
ExecutionTime = 8.6 s ClockTime = 9 s
Time = 0.79
Courant Number mean: 0.102802 max: 0.61667
smoothSolver: Solving for Ux, Initial residual = 0.00100608, Final residual = 2.57753e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015352, Final residual = 6.53372e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00134776, Final residual = 0.00012578, No Iterations 4
time step continuity errors : sum local = 3.10411e-08, global = 3.12097e-09, cumulative = 3.94151e-06
GAMG: Solving for p, Initial residual = 0.000274096, Final residual = 7.76149e-07, No Iterations 16
time step continuity errors : sum local = 1.9157e-10, global = 9.99248e-12, cumulative = 3.94152e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000952027, Final residual = 1.71613e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00298102, Final residual = 5.99849e-06, No Iterations 4
ExecutionTime = 8.62 s ClockTime = 9 s
Time = 0.7925
Courant Number mean: 0.102878 max: 0.616684
smoothSolver: Solving for Ux, Initial residual = 0.00100596, Final residual = 2.5678e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00153242, Final residual = 6.50039e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142874, Final residual = 0.000126488, No Iterations 4
time step continuity errors : sum local = 3.12155e-08, global = 3.12456e-09, cumulative = 3.94464e-06
GAMG: Solving for p, Initial residual = 0.000277362, Final residual = 7.57442e-07, No Iterations 16
time step continuity errors : sum local = 1.86925e-10, global = 9.22177e-12, cumulative = 3.94465e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000951005, Final residual = 1.71084e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00297308, Final residual = 5.97786e-06, No Iterations 4
ExecutionTime = 8.65 s ClockTime = 9 s
Time = 0.795
Courant Number mean: 0.102955 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.00100585, Final residual = 2.55883e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00153108, Final residual = 6.46743e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00137541, Final residual = 0.000125502, No Iterations 4
time step continuity errors : sum local = 3.09698e-08, global = 3.10432e-09, cumulative = 3.94776e-06
GAMG: Solving for p, Initial residual = 0.000273806, Final residual = 7.71309e-07, No Iterations 16
time step continuity errors : sum local = 1.90343e-10, global = 9.78287e-12, cumulative = 3.94777e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000949884, Final residual = 1.70789e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00296516, Final residual = 5.95655e-06, No Iterations 4
ExecutionTime = 8.67 s ClockTime = 9 s
Time = 0.7975
Courant Number mean: 0.103031 max: 0.616709
smoothSolver: Solving for Ux, Initial residual = 0.00100574, Final residual = 2.54967e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00153019, Final residual = 6.4341e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00134893, Final residual = 0.000127784, No Iterations 4
time step continuity errors : sum local = 3.15326e-08, global = 3.17111e-09, cumulative = 3.95094e-06
GAMG: Solving for p, Initial residual = 0.000274195, Final residual = 7.45932e-07, No Iterations 16
time step continuity errors : sum local = 1.84087e-10, global = 8.85403e-12, cumulative = 3.95095e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000948806, Final residual = 1.70011e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00295707, Final residual = 5.93752e-06, No Iterations 4
ExecutionTime = 8.69 s ClockTime = 9 s
Time = 0.8
Courant Number mean: 0.103107 max: 0.616722
smoothSolver: Solving for Ux, Initial residual = 0.00100563, Final residual = 2.54115e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152976, Final residual = 6.40196e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00133548, Final residual = 0.000126558, No Iterations 4
time step continuity errors : sum local = 3.12326e-08, global = 3.1373e-09, cumulative = 3.95408e-06
GAMG: Solving for p, Initial residual = 0.000273745, Final residual = 7.48481e-07, No Iterations 16
time step continuity errors : sum local = 1.84737e-10, global = 9.12316e-12, cumulative = 3.95409e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000947828, Final residual = 1.69989e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00294898, Final residual = 5.91906e-06, No Iterations 4
ExecutionTime = 8.74 s ClockTime = 9 s
Time = 0.8025
Courant Number mean: 0.103183 max: 0.616734
smoothSolver: Solving for Ux, Initial residual = 0.00100551, Final residual = 2.53218e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152941, Final residual = 6.36942e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00136647, Final residual = 0.00012636, No Iterations 4
time step continuity errors : sum local = 3.11858e-08, global = 3.14687e-09, cumulative = 3.95724e-06
GAMG: Solving for p, Initial residual = 0.000272564, Final residual = 7.43654e-07, No Iterations 16
time step continuity errors : sum local = 1.83549e-10, global = 8.95751e-12, cumulative = 3.95725e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000946913, Final residual = 1.69572e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00294141, Final residual = 5.90074e-06, No Iterations 4
ExecutionTime = 8.77 s ClockTime = 9 s
Time = 0.805
Courant Number mean: 0.103258 max: 0.616746
smoothSolver: Solving for Ux, Initial residual = 0.00100539, Final residual = 2.52381e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152888, Final residual = 6.33742e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142601, Final residual = 0.000126642, No Iterations 4
time step continuity errors : sum local = 3.12577e-08, global = 3.15807e-09, cumulative = 3.96041e-06
GAMG: Solving for p, Initial residual = 0.000274535, Final residual = 7.28743e-07, No Iterations 16
time step continuity errors : sum local = 1.79889e-10, global = 8.49397e-12, cumulative = 3.96042e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000945927, Final residual = 1.69269e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00293486, Final residual = 5.88153e-06, No Iterations 4
ExecutionTime = 8.79 s ClockTime = 9 s
Time = 0.8075
Courant Number mean: 0.103333 max: 0.616758
smoothSolver: Solving for Ux, Initial residual = 0.00100531, Final residual = 2.51487e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152805, Final residual = 6.30569e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00139965, Final residual = 0.000124158, No Iterations 4
time step continuity errors : sum local = 3.06443e-08, global = 3.12723e-09, cumulative = 3.96354e-06
GAMG: Solving for p, Initial residual = 0.000275011, Final residual = 7.42488e-07, No Iterations 16
time step continuity errors : sum local = 1.83261e-10, global = 9.0868e-12, cumulative = 3.96355e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000944969, Final residual = 1.68714e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00292877, Final residual = 5.86188e-06, No Iterations 4
ExecutionTime = 8.82 s ClockTime = 9 s
Time = 0.81
Courant Number mean: 0.103408 max: 0.616769
smoothSolver: Solving for Ux, Initial residual = 0.0010052, Final residual = 2.50644e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152706, Final residual = 6.27432e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00133194, Final residual = 0.000126693, No Iterations 4
time step continuity errors : sum local = 3.12692e-08, global = 3.17075e-09, cumulative = 3.96672e-06
GAMG: Solving for p, Initial residual = 0.000272849, Final residual = 7.21982e-07, No Iterations 16
time step continuity errors : sum local = 1.78209e-10, global = 8.43248e-12, cumulative = 3.96673e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00094395, Final residual = 1.68143e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00292296, Final residual = 5.8439e-06, No Iterations 4
ExecutionTime = 8.84 s ClockTime = 9 s
Time = 0.8125
Courant Number mean: 0.103483 max: 0.616781
smoothSolver: Solving for Ux, Initial residual = 0.00100508, Final residual = 2.49776e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152538, Final residual = 6.24275e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00131916, Final residual = 0.000124507, No Iterations 4
time step continuity errors : sum local = 3.07317e-08, global = 3.11686e-09, cumulative = 3.96985e-06
GAMG: Solving for p, Initial residual = 0.000272911, Final residual = 7.22871e-07, No Iterations 16
time step continuity errors : sum local = 1.78443e-10, global = 8.33222e-12, cumulative = 3.96986e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000942859, Final residual = 1.67745e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00291713, Final residual = 5.82132e-06, No Iterations 4
ExecutionTime = 8.87 s ClockTime = 9 s
Time = 0.815
Courant Number mean: 0.103557 max: 0.616792
smoothSolver: Solving for Ux, Initial residual = 0.00100496, Final residual = 2.48941e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152323, Final residual = 6.21241e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00130329, Final residual = 0.000125424, No Iterations 4
time step continuity errors : sum local = 3.09609e-08, global = 3.12455e-09, cumulative = 3.97298e-06
GAMG: Solving for p, Initial residual = 0.000272521, Final residual = 7.15026e-07, No Iterations 16
time step continuity errors : sum local = 1.76522e-10, global = 8.15033e-12, cumulative = 3.97299e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000941693, Final residual = 1.67279e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00291098, Final residual = 5.80141e-06, No Iterations 4
ExecutionTime = 8.89 s ClockTime = 9 s
Time = 0.8175
Courant Number mean: 0.103632 max: 0.616803
smoothSolver: Solving for Ux, Initial residual = 0.00100483, Final residual = 2.48033e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152136, Final residual = 6.18154e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00128781, Final residual = 7.55406e-05, No Iterations 5
time step continuity errors : sum local = 1.86501e-08, global = -1.70587e-09, cumulative = 3.97128e-06
GAMG: Solving for p, Initial residual = 0.000249291, Final residual = 7.04087e-07, No Iterations 15
time step continuity errors : sum local = 1.73849e-10, global = 5.34706e-12, cumulative = 3.97129e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000940439, Final residual = 1.668e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00290424, Final residual = 5.78308e-06, No Iterations 4
ExecutionTime = 8.91 s ClockTime = 9 s
Time = 0.82
Courant Number mean: 0.103705 max: 0.616813
smoothSolver: Solving for Ux, Initial residual = 0.00100479, Final residual = 2.47379e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151969, Final residual = 6.15423e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00131802, Final residual = 0.000130808, No Iterations 4
time step continuity errors : sum local = 3.23039e-08, global = 3.38183e-09, cumulative = 3.97467e-06
GAMG: Solving for p, Initial residual = 0.000272574, Final residual = 6.93644e-07, No Iterations 16
time step continuity errors : sum local = 1.7133e-10, global = 7.31118e-12, cumulative = 3.97468e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000939145, Final residual = 1.66778e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00289733, Final residual = 5.76396e-06, No Iterations 4
ExecutionTime = 8.93 s ClockTime = 9 s
Time = 0.8225
Courant Number mean: 0.103778 max: 0.616824
smoothSolver: Solving for Ux, Initial residual = 0.00100467, Final residual = 2.46104e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.001518, Final residual = 6.12272e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129465, Final residual = 7.55156e-05, No Iterations 5
time step continuity errors : sum local = 1.86531e-08, global = -1.71917e-09, cumulative = 3.97296e-06
GAMG: Solving for p, Initial residual = 0.000249199, Final residual = 6.93919e-07, No Iterations 15
time step continuity errors : sum local = 1.71424e-10, global = 5.30756e-12, cumulative = 3.97296e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000938155, Final residual = 1.66479e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00289024, Final residual = 5.74363e-06, No Iterations 4
ExecutionTime = 8.95 s ClockTime = 9 s
Time = 0.825
Courant Number mean: 0.103851 max: 0.616834
smoothSolver: Solving for Ux, Initial residual = 0.00100466, Final residual = 2.45742e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151621, Final residual = 6.09773e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129147, Final residual = 0.000127265, No Iterations 4
time step continuity errors : sum local = 3.14445e-08, global = 3.31934e-09, cumulative = 3.97628e-06
GAMG: Solving for p, Initial residual = 0.000267834, Final residual = 5.81221e-07, No Iterations 16
time step continuity errors : sum local = 1.4363e-10, global = 4.8708e-12, cumulative = 3.97629e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000937235, Final residual = 1.66307e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.002883, Final residual = 5.72313e-06, No Iterations 4
ExecutionTime = 8.98 s ClockTime = 9 s
Time = 0.8275
Courant Number mean: 0.103924 max: 0.616844
smoothSolver: Solving for Ux, Initial residual = 0.00100453, Final residual = 2.44221e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151412, Final residual = 6.06698e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0013059, Final residual = 0.000129683, No Iterations 4
time step continuity errors : sum local = 3.20488e-08, global = 3.10734e-09, cumulative = 3.9794e-06
GAMG: Solving for p, Initial residual = 0.000278372, Final residual = 5.86413e-07, No Iterations 16
time step continuity errors : sum local = 1.44946e-10, global = 4.90387e-12, cumulative = 3.9794e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000936355, Final residual = 1.65826e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00287554, Final residual = 5.70386e-06, No Iterations 4
ExecutionTime = 9 s ClockTime = 9 s
Time = 0.83
Courant Number mean: 0.103996 max: 0.616853
smoothSolver: Solving for Ux, Initial residual = 0.00100453, Final residual = 2.44094e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151254, Final residual = 6.04252e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129572, Final residual = 7.43533e-05, No Iterations 5
time step continuity errors : sum local = 1.8381e-08, global = -1.64613e-09, cumulative = 3.97775e-06
GAMG: Solving for p, Initial residual = 0.0002481, Final residual = 6.95533e-07, No Iterations 15
time step continuity errors : sum local = 1.71967e-10, global = 5.13575e-12, cumulative = 3.97776e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000935348, Final residual = 1.65499e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00286833, Final residual = 5.68519e-06, No Iterations 4
ExecutionTime = 9.02 s ClockTime = 9 s
Time = 0.8325
Courant Number mean: 0.104068 max: 0.616863
smoothSolver: Solving for Ux, Initial residual = 0.00100443, Final residual = 2.42841e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015116, Final residual = 6.01547e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129628, Final residual = 9.14751e-05, No Iterations 5
time step continuity errors : sum local = 2.26182e-08, global = -2.52856e-09, cumulative = 3.97523e-06
GAMG: Solving for p, Initial residual = 0.000259693, Final residual = 7.60657e-07, No Iterations 15
time step continuity errors : sum local = 1.88091e-10, global = 5.35031e-12, cumulative = 3.97524e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000934323, Final residual = 1.64983e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00286073, Final residual = 5.66563e-06, No Iterations 4
ExecutionTime = 9.05 s ClockTime = 9 s
Time = 0.835
Courant Number mean: 0.104139 max: 0.616872
smoothSolver: Solving for Ux, Initial residual = 0.00100435, Final residual = 2.42296e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151106, Final residual = 5.98768e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0014327, Final residual = 0.0001299, No Iterations 4
time step continuity errors : sum local = 3.21228e-08, global = 3.40023e-09, cumulative = 3.97864e-06
GAMG: Solving for p, Initial residual = 0.00027343, Final residual = 5.92211e-07, No Iterations 16
time step continuity errors : sum local = 1.4646e-10, global = 5.02277e-12, cumulative = 3.97864e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000933325, Final residual = 1.6452e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00285276, Final residual = 5.64779e-06, No Iterations 4
ExecutionTime = 9.07 s ClockTime = 9 s
Time = 0.8375
Courant Number mean: 0.104212 max: 0.616881
smoothSolver: Solving for Ux, Initial residual = 0.0010042, Final residual = 2.41129e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015113, Final residual = 5.95927e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00135776, Final residual = 0.000131823, No Iterations 4
time step continuity errors : sum local = 3.26014e-08, global = 3.11946e-09, cumulative = 3.98176e-06
GAMG: Solving for p, Initial residual = 0.000280377, Final residual = 5.75938e-07, No Iterations 16
time step continuity errors : sum local = 1.42451e-10, global = 4.65843e-12, cumulative = 3.98177e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000932315, Final residual = 1.64098e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0028455, Final residual = 5.62991e-06, No Iterations 4
ExecutionTime = 9.09 s ClockTime = 9 s
Time = 0.84
Courant Number mean: 0.104286 max: 0.61689
smoothSolver: Solving for Ux, Initial residual = 0.00100412, Final residual = 2.40855e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151187, Final residual = 5.93527e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129525, Final residual = 7.33064e-05, No Iterations 5
time step continuity errors : sum local = 1.8133e-08, global = -1.6006e-09, cumulative = 3.98017e-06
GAMG: Solving for p, Initial residual = 0.000249235, Final residual = 7.22648e-07, No Iterations 15
time step continuity errors : sum local = 1.78767e-10, global = 5.41013e-12, cumulative = 3.98017e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000931364, Final residual = 1.63864e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00283914, Final residual = 5.61136e-06, No Iterations 4
ExecutionTime = 9.12 s ClockTime = 9 s
Time = 0.8425
Courant Number mean: 0.104359 max: 0.616898
smoothSolver: Solving for Ux, Initial residual = 0.00100398, Final residual = 2.39805e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151188, Final residual = 5.90915e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129429, Final residual = 9.17033e-05, No Iterations 5
time step continuity errors : sum local = 2.26878e-08, global = -2.54675e-09, cumulative = 3.97762e-06
GAMG: Solving for p, Initial residual = 0.000260058, Final residual = 7.51139e-07, No Iterations 15
time step continuity errors : sum local = 1.85853e-10, global = 5.20956e-12, cumulative = 3.97763e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000930407, Final residual = 1.63375e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.002833, Final residual = 5.59214e-06, No Iterations 4
ExecutionTime = 9.14 s ClockTime = 9 s
Time = 0.845
Courant Number mean: 0.104433 max: 0.616907
smoothSolver: Solving for Ux, Initial residual = 0.00100383, Final residual = 2.39141e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151162, Final residual = 5.88211e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129666, Final residual = 9.35741e-05, No Iterations 5
time step continuity errors : sum local = 2.31548e-08, global = -2.62663e-09, cumulative = 3.975e-06
GAMG: Solving for p, Initial residual = 0.000261372, Final residual = 7.47469e-07, No Iterations 15
time step continuity errors : sum local = 1.84974e-10, global = 5.11583e-12, cumulative = 3.97501e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000929432, Final residual = 1.63043e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00282708, Final residual = 5.57224e-06, No Iterations 4
ExecutionTime = 9.16 s ClockTime = 9 s
Time = 0.8475
Courant Number mean: 0.104507 max: 0.616915
smoothSolver: Solving for Ux, Initial residual = 0.00100366, Final residual = 2.38283e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151091, Final residual = 5.85684e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129822, Final residual = 9.37029e-05, No Iterations 5
time step continuity errors : sum local = 2.31915e-08, global = -2.63353e-09, cumulative = 3.97237e-06
GAMG: Solving for p, Initial residual = 0.000261211, Final residual = 7.50593e-07, No Iterations 15
time step continuity errors : sum local = 1.85794e-10, global = 5.1468e-12, cumulative = 3.97238e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000928363, Final residual = 1.62709e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00282132, Final residual = 5.55415e-06, No Iterations 4
ExecutionTime = 9.19 s ClockTime = 9 s
Time = 0.85
Courant Number mean: 0.104582 max: 0.616923
smoothSolver: Solving for Ux, Initial residual = 0.00100348, Final residual = 2.37579e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150989, Final residual = 5.83051e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00131091, Final residual = 9.36596e-05, No Iterations 5
time step continuity errors : sum local = 2.31875e-08, global = -2.64252e-09, cumulative = 3.96974e-06
GAMG: Solving for p, Initial residual = 0.000260377, Final residual = 7.52998e-07, No Iterations 15
time step continuity errors : sum local = 1.86451e-10, global = 5.15065e-12, cumulative = 3.96974e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000927273, Final residual = 1.62684e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00281538, Final residual = 5.53519e-06, No Iterations 4
ExecutionTime = 9.21 s ClockTime = 9 s
Time = 0.8525
Courant Number mean: 0.104656 max: 0.616931
smoothSolver: Solving for Ux, Initial residual = 0.00100333, Final residual = 2.36793e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150831, Final residual = 5.80506e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00135494, Final residual = 0.000132494, No Iterations 4
time step continuity errors : sum local = 3.28115e-08, global = 3.44351e-09, cumulative = 3.97319e-06
GAMG: Solving for p, Initial residual = 0.00027205, Final residual = 5.89856e-07, No Iterations 16
time step continuity errors : sum local = 1.461e-10, global = 5.00238e-12, cumulative = 3.97319e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000926175, Final residual = 9.9981e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00280917, Final residual = 5.51684e-06, No Iterations 4
ExecutionTime = 9.23 s ClockTime = 9 s
Time = 0.855
Courant Number mean: 0.104731 max: 0.616938
smoothSolver: Solving for Ux, Initial residual = 0.00100313, Final residual = 2.35884e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150671, Final residual = 5.77995e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00135927, Final residual = 0.000133217, No Iterations 4
time step continuity errors : sum local = 3.29969e-08, global = 3.09866e-09, cumulative = 3.97629e-06
GAMG: Solving for p, Initial residual = 0.000284511, Final residual = 6.04816e-07, No Iterations 16
time step continuity errors : sum local = 1.49824e-10, global = 5.15914e-12, cumulative = 3.97629e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000925255, Final residual = 9.99078e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0028031, Final residual = 5.51008e-06, No Iterations 4
ExecutionTime = 9.26 s ClockTime = 9 s
Time = 0.8575
Courant Number mean: 0.104807 max: 0.616946
smoothSolver: Solving for Ux, Initial residual = 0.00100298, Final residual = 2.35613e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150551, Final residual = 5.76086e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00141262, Final residual = 0.000134129, No Iterations 4
time step continuity errors : sum local = 3.32259e-08, global = 3.06907e-09, cumulative = 3.97936e-06
GAMG: Solving for p, Initial residual = 0.000285654, Final residual = 5.62476e-07, No Iterations 16
time step continuity errors : sum local = 1.39337e-10, global = 4.33742e-12, cumulative = 3.97937e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000924515, Final residual = 9.99462e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00279688, Final residual = 5.50116e-06, No Iterations 4
ExecutionTime = 9.28 s ClockTime = 9 s
Time = 0.86
Courant Number mean: 0.104883 max: 0.616953
smoothSolver: Solving for Ux, Initial residual = 0.00100283, Final residual = 2.34592e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150392, Final residual = 5.73751e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00156868, Final residual = 0.000135054, No Iterations 4
time step continuity errors : sum local = 3.34547e-08, global = 3.11907e-09, cumulative = 3.98249e-06
GAMG: Solving for p, Initial residual = 0.000289671, Final residual = 5.89441e-07, No Iterations 16
time step continuity errors : sum local = 1.46016e-10, global = 4.8024e-12, cumulative = 3.98249e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000923787, Final residual = 1.63342e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00279049, Final residual = 5.49148e-06, No Iterations 4
ExecutionTime = 9.3 s ClockTime = 9 s
Time = 0.8625
Courant Number mean: 0.104961 max: 0.61696
smoothSolver: Solving for Ux, Initial residual = 0.00100274, Final residual = 2.34096e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150239, Final residual = 5.71556e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00147849, Final residual = 0.000137096, No Iterations 4
time step continuity errors : sum local = 3.39619e-08, global = 2.90099e-09, cumulative = 3.98539e-06
GAMG: Solving for p, Initial residual = 0.00028835, Final residual = 5.50092e-07, No Iterations 16
time step continuity errors : sum local = 1.36278e-10, global = 4.20636e-12, cumulative = 3.9854e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00092288, Final residual = 1.63122e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00278357, Final residual = 5.47293e-06, No Iterations 4
ExecutionTime = 9.32 s ClockTime = 9 s
Time = 0.865
Courant Number mean: 0.105039 max: 0.616967
smoothSolver: Solving for Ux, Initial residual = 0.00100261, Final residual = 2.33065e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150094, Final residual = 5.69105e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00140837, Final residual = 0.00013615, No Iterations 4
time step continuity errors : sum local = 3.37284e-08, global = 3.04156e-09, cumulative = 3.98844e-06
GAMG: Solving for p, Initial residual = 0.000284275, Final residual = 5.65607e-07, No Iterations 16
time step continuity errors : sum local = 1.40122e-10, global = 4.41135e-12, cumulative = 3.98844e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000921971, Final residual = 9.99208e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00277639, Final residual = 5.45468e-06, No Iterations 4
ExecutionTime = 9.35 s ClockTime = 9 s
Time = 0.8675
Courant Number mean: 0.105117 max: 0.616974
smoothSolver: Solving for Ux, Initial residual = 0.00100251, Final residual = 2.32661e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150028, Final residual = 5.67166e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00133232, Final residual = 7.67581e-05, No Iterations 5
time step continuity errors : sum local = 1.90165e-08, global = -1.75567e-09, cumulative = 3.98669e-06
GAMG: Solving for p, Initial residual = 0.000250918, Final residual = 6.91868e-07, No Iterations 15
time step continuity errors : sum local = 1.71414e-10, global = 4.93377e-12, cumulative = 3.98669e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00092123, Final residual = 9.9833e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00276941, Final residual = 5.44736e-06, No Iterations 4
ExecutionTime = 9.37 s ClockTime = 9 s
Time = 0.87
Courant Number mean: 0.105195 max: 0.616981
smoothSolver: Solving for Ux, Initial residual = 0.0010024, Final residual = 2.31892e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015003, Final residual = 5.65147e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00131647, Final residual = 9.411e-05, No Iterations 5
time step continuity errors : sum local = 2.33191e-08, global = -2.68848e-09, cumulative = 3.984e-06
GAMG: Solving for p, Initial residual = 0.000263644, Final residual = 7.43843e-07, No Iterations 15
time step continuity errors : sum local = 1.84331e-10, global = 5.02691e-12, cumulative = 3.98401e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000920435, Final residual = 9.96628e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00276223, Final residual = 5.4396e-06, No Iterations 4
ExecutionTime = 9.39 s ClockTime = 9 s
Time = 0.8725
Courant Number mean: 0.105273 max: 0.616988
smoothSolver: Solving for Ux, Initial residual = 0.00100227, Final residual = 2.31251e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015007, Final residual = 5.63123e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00132714, Final residual = 9.5307e-05, No Iterations 5
time step continuity errors : sum local = 2.36214e-08, global = -2.73679e-09, cumulative = 3.98127e-06
GAMG: Solving for p, Initial residual = 0.00026445, Final residual = 7.44066e-07, No Iterations 15
time step continuity errors : sum local = 1.84435e-10, global = 5.01019e-12, cumulative = 3.98128e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000919721, Final residual = 9.94572e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00275556, Final residual = 5.43179e-06, No Iterations 4
ExecutionTime = 9.42 s ClockTime = 10 s
Time = 0.875
Courant Number mean: 0.10535 max: 0.616994
smoothSolver: Solving for Ux, Initial residual = 0.00100214, Final residual = 2.30606e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150122, Final residual = 5.61182e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00133349, Final residual = 9.61147e-05, No Iterations 5
time step continuity errors : sum local = 2.38286e-08, global = -2.77022e-09, cumulative = 3.97851e-06
GAMG: Solving for p, Initial residual = 0.000268073, Final residual = 7.43465e-07, No Iterations 15
time step continuity errors : sum local = 1.84345e-10, global = 4.97437e-12, cumulative = 3.97851e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000919028, Final residual = 9.94703e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00274981, Final residual = 5.42237e-06, No Iterations 4
ExecutionTime = 9.44 s ClockTime = 10 s
Time = 0.8775
Courant Number mean: 0.105427 max: 0.617001
smoothSolver: Solving for Ux, Initial residual = 0.00100198, Final residual = 2.29973e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150186, Final residual = 5.59272e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00138049, Final residual = 0.000133516, No Iterations 4
time step continuity errors : sum local = 3.31132e-08, global = 3.51347e-09, cumulative = 3.98203e-06
GAMG: Solving for p, Initial residual = 0.000276075, Final residual = 6.04554e-07, No Iterations 16
time step continuity errors : sum local = 1.49971e-10, global = 5.22911e-12, cumulative = 3.98203e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000918334, Final residual = 9.93004e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00274421, Final residual = 5.41367e-06, No Iterations 4
ExecutionTime = 9.46 s ClockTime = 10 s
Time = 0.88
Courant Number mean: 0.105504 max: 0.617007
smoothSolver: Solving for Ux, Initial residual = 0.00100179, Final residual = 2.29119e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150197, Final residual = 5.57513e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00135377, Final residual = 7.82815e-05, No Iterations 5
time step continuity errors : sum local = 1.94209e-08, global = -1.80649e-09, cumulative = 3.98022e-06
GAMG: Solving for p, Initial residual = 0.000258556, Final residual = 6.63631e-07, No Iterations 15
time step continuity errors : sum local = 1.64664e-10, global = 4.74261e-12, cumulative = 3.98023e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000917643, Final residual = 9.91051e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00273874, Final residual = 5.40317e-06, No Iterations 4
ExecutionTime = 9.49 s ClockTime = 10 s
Time = 0.8825
Courant Number mean: 0.10558 max: 0.617014
smoothSolver: Solving for Ux, Initial residual = 0.0010017, Final residual = 2.28927e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150202, Final residual = 5.55664e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00139109, Final residual = 0.000133586, No Iterations 4
time step continuity errors : sum local = 3.31489e-08, global = 3.50017e-09, cumulative = 3.98373e-06
GAMG: Solving for p, Initial residual = 0.000276452, Final residual = 5.88204e-07, No Iterations 16
time step continuity errors : sum local = 1.45971e-10, global = 4.93848e-12, cumulative = 3.98373e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000916861, Final residual = 9.9023e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00273352, Final residual = 5.39586e-06, No Iterations 4
ExecutionTime = 9.51 s ClockTime = 10 s
Time = 0.885
Courant Number mean: 0.105657 max: 0.61702
smoothSolver: Solving for Ux, Initial residual = 0.00100146, Final residual = 2.27701e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150179, Final residual = 5.53851e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00140355, Final residual = 0.00013489, No Iterations 4
time step continuity errors : sum local = 3.34737e-08, global = 3.19399e-09, cumulative = 3.98693e-06
GAMG: Solving for p, Initial residual = 0.000284684, Final residual = 5.80414e-07, No Iterations 16
time step continuity errors : sum local = 1.44048e-10, global = 4.79247e-12, cumulative = 3.98693e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000916061, Final residual = 9.91326e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00272805, Final residual = 5.38459e-06, No Iterations 4
ExecutionTime = 9.53 s ClockTime = 10 s
Time = 0.8875
Courant Number mean: 0.105732 max: 0.617026
smoothSolver: Solving for Ux, Initial residual = 0.00100129, Final residual = 2.27507e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150152, Final residual = 5.52178e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00136003, Final residual = 7.61783e-05, No Iterations 5
time step continuity errors : sum local = 1.8908e-08, global = -1.73946e-09, cumulative = 3.98519e-06
GAMG: Solving for p, Initial residual = 0.000253321, Final residual = 6.88249e-07, No Iterations 15
time step continuity errors : sum local = 1.70851e-10, global = 4.87767e-12, cumulative = 3.9852e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000915272, Final residual = 9.90805e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00272231, Final residual = 5.37287e-06, No Iterations 4
ExecutionTime = 9.56 s ClockTime = 10 s
Time = 0.89
Courant Number mean: 0.105808 max: 0.617032
smoothSolver: Solving for Ux, Initial residual = 0.00100114, Final residual = 2.26858e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015008, Final residual = 5.50129e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00137822, Final residual = 0.000133595, No Iterations 4
time step continuity errors : sum local = 3.31665e-08, global = 3.49082e-09, cumulative = 3.98869e-06
GAMG: Solving for p, Initial residual = 0.000278002, Final residual = 5.67763e-07, No Iterations 16
time step continuity errors : sum local = 1.40967e-10, global = 4.53153e-12, cumulative = 3.98869e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000914444, Final residual = 9.91974e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00271622, Final residual = 5.36196e-06, No Iterations 4
ExecutionTime = 9.58 s ClockTime = 10 s
Time = 0.8925
Courant Number mean: 0.105883 max: 0.617038
smoothSolver: Solving for Ux, Initial residual = 0.00100093, Final residual = 2.25973e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150034, Final residual = 5.48561e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00130648, Final residual = 7.78847e-05, No Iterations 5
time step continuity errors : sum local = 1.93386e-08, global = -1.81085e-09, cumulative = 3.98688e-06
GAMG: Solving for p, Initial residual = 0.000253712, Final residual = 6.76714e-07, No Iterations 15
time step continuity errors : sum local = 1.68044e-10, global = 4.86499e-12, cumulative = 3.98689e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000913752, Final residual = 9.91022e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00271009, Final residual = 5.35249e-06, No Iterations 4
ExecutionTime = 9.6 s ClockTime = 10 s
Time = 0.895
Courant Number mean: 0.105957 max: 0.617044
smoothSolver: Solving for Ux, Initial residual = 0.00100078, Final residual = 2.25849e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00149999, Final residual = 5.46708e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00129534, Final residual = 9.44735e-05, No Iterations 5
time step continuity errors : sum local = 2.34641e-08, global = -2.7346e-09, cumulative = 3.98415e-06
GAMG: Solving for p, Initial residual = 0.000265201, Final residual = 7.63965e-07, No Iterations 15
time step continuity errors : sum local = 1.89765e-10, global = 5.25555e-12, cumulative = 3.98416e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00091311, Final residual = 9.90334e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.002704, Final residual = 5.34117e-06, No Iterations 4
ExecutionTime = 9.63 s ClockTime = 10 s
Time = 0.8975
Courant Number mean: 0.106031 max: 0.617049
smoothSolver: Solving for Ux, Initial residual = 0.0010005, Final residual = 2.24815e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00149966, Final residual = 5.44849e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00134329, Final residual = 9.59863e-05, No Iterations 5
time step continuity errors : sum local = 2.38451e-08, global = -2.7746e-09, cumulative = 3.98138e-06
GAMG: Solving for p, Initial residual = 0.000269139, Final residual = 7.3574e-07, No Iterations 15
time step continuity errors : sum local = 1.82788e-10, global = 4.91279e-12, cumulative = 3.98139e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000912459, Final residual = 9.91644e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00269797, Final residual = 5.33045e-06, No Iterations 4
ExecutionTime = 9.65 s ClockTime = 10 s
Time = 0.9
Courant Number mean: 0.106105 max: 0.617055
smoothSolver: Solving for Ux, Initial residual = 0.00100026, Final residual = 2.24413e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00149922, Final residual = 5.43272e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00132174, Final residual = 9.59611e-05, No Iterations 5
time step continuity errors : sum local = 2.38441e-08, global = -2.79275e-09, cumulative = 3.9786e-06
GAMG: Solving for p, Initial residual = 0.000267407, Final residual = 7.4265e-07, No Iterations 15
time step continuity errors : sum local = 1.84549e-10, global = 4.95866e-12, cumulative = 3.9786e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00091185, Final residual = 9.9089e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00269147, Final residual = 5.31799e-06, No Iterations 4
ExecutionTime = 9.71 s ClockTime = 10 s
Time = 0.9025
Courant Number mean: 0.106178 max: 0.617061
smoothSolver: Solving for Ux, Initial residual = 0.000999998, Final residual = 2.23649e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00149862, Final residual = 5.4163e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00136523, Final residual = 0.000136472, No Iterations 4
time step continuity errors : sum local = 3.39175e-08, global = 3.69444e-09, cumulative = 3.98229e-06
GAMG: Solving for p, Initial residual = 0.000280499, Final residual = 5.99739e-07, No Iterations 16
time step continuity errors : sum local = 1.49073e-10, global = 4.90097e-12, cumulative = 3.9823e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000911219, Final residual = 9.89959e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00268485, Final residual = 5.30648e-06, No Iterations 4
ExecutionTime = 9.74 s ClockTime = 10 s
Time = 0.905
Courant Number mean: 0.106253 max: 0.617066
smoothSolver: Solving for Ux, Initial residual = 0.000999732, Final residual = 2.22943e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00149891, Final residual = 5.40393e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00133032, Final residual = 7.58965e-05, No Iterations 5
time step continuity errors : sum local = 1.88668e-08, global = -1.68386e-09, cumulative = 3.98062e-06
GAMG: Solving for p, Initial residual = 0.000258104, Final residual = 6.59424e-07, No Iterations 15
time step continuity errors : sum local = 1.63952e-10, global = 4.66291e-12, cumulative = 3.98062e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000910526, Final residual = 9.89317e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00267808, Final residual = 5.29565e-06, No Iterations 4
ExecutionTime = 9.76 s ClockTime = 10 s
Time = 0.9075
Courant Number mean: 0.106327 max: 0.617071
smoothSolver: Solving for Ux, Initial residual = 0.000999537, Final residual = 2.22302e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00149951, Final residual = 5.3835e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00131662, Final residual = 9.44553e-05, No Iterations 5
time step continuity errors : sum local = 2.34867e-08, global = -2.68929e-09, cumulative = 3.97793e-06
GAMG: Solving for p, Initial residual = 0.000267158, Final residual = 7.28381e-07, No Iterations 15
time step continuity errors : sum local = 1.81137e-10, global = 4.88952e-12, cumulative = 3.97794e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000909838, Final residual = 9.88498e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00267217, Final residual = 5.28389e-06, No Iterations 4
ExecutionTime = 9.78 s ClockTime = 10 s
Time = 0.91
Courant Number mean: 0.106403 max: 0.617076
smoothSolver: Solving for Ux, Initial residual = 0.000999401, Final residual = 2.22086e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150042, Final residual = 5.37067e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00139876, Final residual = 0.000136328, No Iterations 4
time step continuity errors : sum local = 3.3905e-08, global = 3.73296e-09, cumulative = 3.98167e-06
GAMG: Solving for p, Initial residual = 0.000280749, Final residual = 5.81735e-07, No Iterations 16
time step continuity errors : sum local = 1.44693e-10, global = 4.66314e-12, cumulative = 3.98167e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000909188, Final residual = 9.87897e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00266682, Final residual = 5.27434e-06, No Iterations 4
ExecutionTime = 9.81 s ClockTime = 10 s
Time = 0.9125
Courant Number mean: 0.106478 max: 0.617082
smoothSolver: Solving for Ux, Initial residual = 0.000999232, Final residual = 2.21068e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150126, Final residual = 5.35726e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00137673, Final residual = 7.76742e-05, No Iterations 5
time step continuity errors : sum local = 1.93212e-08, global = -1.74115e-09, cumulative = 3.97993e-06
GAMG: Solving for p, Initial residual = 0.000259461, Final residual = 6.51344e-07, No Iterations 15
time step continuity errors : sum local = 1.62049e-10, global = 4.57071e-12, cumulative = 3.97994e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000908539, Final residual = 9.86854e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00266179, Final residual = 5.26166e-06, No Iterations 4
ExecutionTime = 9.83 s ClockTime = 10 s
Time = 0.915
Courant Number mean: 0.106554 max: 0.617086
smoothSolver: Solving for Ux, Initial residual = 0.000999124, Final residual = 2.20677e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150208, Final residual = 5.33821e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0013926, Final residual = 9.46825e-05, No Iterations 5
time step continuity errors : sum local = 2.35582e-08, global = -2.66311e-09, cumulative = 3.97727e-06
GAMG: Solving for p, Initial residual = 0.000271332, Final residual = 7.6043e-07, No Iterations 15
time step continuity errors : sum local = 1.89224e-10, global = 5.27512e-12, cumulative = 3.97728e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000907929, Final residual = 9.85055e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00265683, Final residual = 5.24978e-06, No Iterations 4
ExecutionTime = 9.85 s ClockTime = 10 s
Time = 0.9175
Courant Number mean: 0.10663 max: 0.617091
smoothSolver: Solving for Ux, Initial residual = 0.000998991, Final residual = 2.20291e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.001503, Final residual = 5.32536e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00144801, Final residual = 0.000138043, No Iterations 4
time step continuity errors : sum local = 3.43576e-08, global = 3.80273e-09, cumulative = 3.98108e-06
GAMG: Solving for p, Initial residual = 0.000285726, Final residual = 5.92581e-07, No Iterations 16
time step continuity errors : sum local = 1.47522e-10, global = 4.84587e-12, cumulative = 3.98109e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000907255, Final residual = 9.83789e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00265187, Final residual = 5.23787e-06, No Iterations 4
ExecutionTime = 9.88 s ClockTime = 10 s
Time = 0.92
Courant Number mean: 0.106707 max: 0.617096
smoothSolver: Solving for Ux, Initial residual = 0.000998758, Final residual = 2.19396e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150346, Final residual = 5.31247e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0014394, Final residual = 7.8158e-05, No Iterations 5
time step continuity errors : sum local = 1.94594e-08, global = -1.6951e-09, cumulative = 3.97939e-06
GAMG: Solving for p, Initial residual = 0.000272716, Final residual = 6.65998e-07, No Iterations 15
time step continuity errors : sum local = 1.65855e-10, global = 4.73274e-12, cumulative = 3.9794e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000906524, Final residual = 9.87323e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00264667, Final residual = 5.22467e-06, No Iterations 4
ExecutionTime = 9.91 s ClockTime = 10 s
Time = 0.9225
Courant Number mean: 0.106783 max: 0.617101
smoothSolver: Solving for Ux, Initial residual = 0.000998571, Final residual = 2.18865e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150394, Final residual = 5.29395e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142527, Final residual = 0.000140697, No Iterations 4
time step continuity errors : sum local = 3.50393e-08, global = 3.84871e-09, cumulative = 3.98325e-06
GAMG: Solving for p, Initial residual = 0.000289905, Final residual = 5.85031e-07, No Iterations 16
time step continuity errors : sum local = 1.45716e-10, global = 4.69264e-12, cumulative = 3.98325e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000905791, Final residual = 9.84608e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00264114, Final residual = 5.21189e-06, No Iterations 4
ExecutionTime = 9.93 s ClockTime = 10 s
Time = 0.925
Courant Number mean: 0.106859 max: 0.617105
smoothSolver: Solving for Ux, Initial residual = 0.000998329, Final residual = 2.18391e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150368, Final residual = 5.28447e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00149569, Final residual = 7.83273e-05, No Iterations 5
time step continuity errors : sum local = 1.95085e-08, global = -1.71194e-09, cumulative = 3.98154e-06
GAMG: Solving for p, Initial residual = 0.000264951, Final residual = 6.66343e-07, No Iterations 15
time step continuity errors : sum local = 1.65974e-10, global = 4.80732e-12, cumulative = 3.98154e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000904987, Final residual = 9.83873e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00263524, Final residual = 5.19866e-06, No Iterations 4
ExecutionTime = 9.95 s ClockTime = 10 s
Time = 0.9275
Courant Number mean: 0.106936 max: 0.61711
smoothSolver: Solving for Ux, Initial residual = 0.00099813, Final residual = 2.17628e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150307, Final residual = 5.26432e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00146733, Final residual = 0.000143265, No Iterations 4
time step continuity errors : sum local = 3.56864e-08, global = 3.94705e-09, cumulative = 3.98549e-06
GAMG: Solving for p, Initial residual = 0.000290841, Final residual = 5.94589e-07, No Iterations 16
time step continuity errors : sum local = 1.48131e-10, global = 4.79778e-12, cumulative = 3.98549e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00090428, Final residual = 9.84773e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00262929, Final residual = 5.18525e-06, No Iterations 4
ExecutionTime = 9.98 s ClockTime = 10 s
Time = 0.93
Courant Number mean: 0.107012 max: 0.617114
smoothSolver: Solving for Ux, Initial residual = 0.000997965, Final residual = 2.17345e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150235, Final residual = 5.25664e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00149827, Final residual = 7.85239e-05, No Iterations 5
time step continuity errors : sum local = 1.95627e-08, global = -1.71918e-09, cumulative = 3.98378e-06
GAMG: Solving for p, Initial residual = 0.000264981, Final residual = 6.7172e-07, No Iterations 15
time step continuity errors : sum local = 1.67363e-10, global = 4.89463e-12, cumulative = 3.98378e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000903653, Final residual = 9.83938e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00262318, Final residual = 5.17293e-06, No Iterations 4
ExecutionTime = 10 s ClockTime = 10 s
Time = 0.9325
Courant Number mean: 0.107088 max: 0.617118
smoothSolver: Solving for Ux, Initial residual = 0.000997793, Final residual = 2.16438e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150158, Final residual = 5.23487e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142821, Final residual = 9.60616e-05, No Iterations 5
time step continuity errors : sum local = 2.3934e-08, global = -2.74423e-09, cumulative = 3.98104e-06
GAMG: Solving for p, Initial residual = 0.000271904, Final residual = 7.03204e-07, No Iterations 15
time step continuity errors : sum local = 1.75212e-10, global = 4.63318e-12, cumulative = 3.98104e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000903038, Final residual = 9.84049e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00261713, Final residual = 5.15946e-06, No Iterations 4
ExecutionTime = 10.02 s ClockTime = 10 s
Time = 0.935
Courant Number mean: 0.107164 max: 0.617122
smoothSolver: Solving for Ux, Initial residual = 0.000997641, Final residual = 2.16404e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150125, Final residual = 5.22426e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00141704, Final residual = 9.75806e-05, No Iterations 5
time step continuity errors : sum local = 2.43155e-08, global = -2.8579e-09, cumulative = 3.97818e-06
GAMG: Solving for p, Initial residual = 0.000272576, Final residual = 7.15704e-07, No Iterations 15
time step continuity errors : sum local = 1.78348e-10, global = 4.72646e-12, cumulative = 3.97819e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000902457, Final residual = 9.83885e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00261094, Final residual = 5.14732e-06, No Iterations 4
ExecutionTime = 10.05 s ClockTime = 10 s
Time = 0.9375
Courant Number mean: 0.10724 max: 0.617126
smoothSolver: Solving for Ux, Initial residual = 0.00099742, Final residual = 2.15526e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150095, Final residual = 5.20886e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00137656, Final residual = 9.83322e-05, No Iterations 5
time step continuity errors : sum local = 2.45067e-08, global = -2.85548e-09, cumulative = 3.97533e-06
GAMG: Solving for p, Initial residual = 0.000272595, Final residual = 7.09668e-07, No Iterations 15
time step continuity errors : sum local = 1.76884e-10, global = 4.64623e-12, cumulative = 3.97534e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000901829, Final residual = 9.83503e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00260455, Final residual = 5.13254e-06, No Iterations 4
ExecutionTime = 10.07 s ClockTime = 10 s
Time = 0.94
Courant Number mean: 0.107317 max: 0.617129
smoothSolver: Solving for Ux, Initial residual = 0.000997207, Final residual = 2.15172e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150055, Final residual = 5.19658e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00147185, Final residual = 9.91292e-05, No Iterations 5
time step continuity errors : sum local = 2.47121e-08, global = -2.87642e-09, cumulative = 3.97246e-06
GAMG: Solving for p, Initial residual = 0.000280382, Final residual = 7.12331e-07, No Iterations 15
time step continuity errors : sum local = 1.77602e-10, global = 4.65655e-12, cumulative = 3.97247e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000901215, Final residual = 9.83226e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0025981, Final residual = 5.11812e-06, No Iterations 4
ExecutionTime = 10.1 s ClockTime = 10 s
Time = 0.9425
Courant Number mean: 0.107393 max: 0.617133
smoothSolver: Solving for Ux, Initial residual = 0.000996963, Final residual = 2.14518e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150114, Final residual = 5.18363e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00149515, Final residual = 0.000144016, No Iterations 4
time step continuity errors : sum local = 3.59095e-08, global = 4.07542e-09, cumulative = 3.97654e-06
GAMG: Solving for p, Initial residual = 0.000299146, Final residual = 5.78417e-07, No Iterations 16
time step continuity errors : sum local = 1.44238e-10, global = 4.6972e-12, cumulative = 3.97655e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000900588, Final residual = 9.81409e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00259216, Final residual = 5.10398e-06, No Iterations 4
ExecutionTime = 10.12 s ClockTime = 10 s
Time = 0.945
Courant Number mean: 0.10747 max: 0.617136
smoothSolver: Solving for Ux, Initial residual = 0.000996638, Final residual = 2.13839e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150208, Final residual = 5.17338e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0013978, Final residual = 7.93151e-05, No Iterations 5
time step continuity errors : sum local = 1.97797e-08, global = -1.73221e-09, cumulative = 3.97481e-06
GAMG: Solving for p, Initial residual = 0.000264601, Final residual = 6.38876e-07, No Iterations 15
time step continuity errors : sum local = 1.59352e-10, global = 4.65823e-12, cumulative = 3.97482e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000899947, Final residual = 9.80948e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00258678, Final residual = 5.09064e-06, No Iterations 4
ExecutionTime = 10.14 s ClockTime = 10 s
Time = 0.9475
Courant Number mean: 0.107546 max: 0.61714
smoothSolver: Solving for Ux, Initial residual = 0.000996395, Final residual = 2.13297e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150343, Final residual = 5.15577e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00135577, Final residual = 9.83825e-05, No Iterations 5
time step continuity errors : sum local = 2.45412e-08, global = -2.78196e-09, cumulative = 3.97204e-06
GAMG: Solving for p, Initial residual = 0.000276081, Final residual = 7.18831e-07, No Iterations 15
time step continuity errors : sum local = 1.79334e-10, global = 4.80022e-12, cumulative = 3.97204e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000899238, Final residual = 9.81671e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00258172, Final residual = 5.07706e-06, No Iterations 4
ExecutionTime = 10.16 s ClockTime = 10 s
Time = 0.95
Courant Number mean: 0.107623 max: 0.617143
smoothSolver: Solving for Ux, Initial residual = 0.000996157, Final residual = 2.13178e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150513, Final residual = 5.14656e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00137648, Final residual = 9.8944e-05, No Iterations 5
time step continuity errors : sum local = 2.46887e-08, global = -2.87239e-09, cumulative = 3.96917e-06
GAMG: Solving for p, Initial residual = 0.000274976, Final residual = 7.12116e-07, No Iterations 15
time step continuity errors : sum local = 1.7771e-10, global = 4.72537e-12, cumulative = 3.96917e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000898532, Final residual = 9.81037e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00257677, Final residual = 5.06205e-06, No Iterations 4
ExecutionTime = 10.19 s ClockTime = 10 s
Time = 0.9525
Courant Number mean: 0.107699 max: 0.617146
smoothSolver: Solving for Ux, Initial residual = 0.000995872, Final residual = 2.12428e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150662, Final residual = 5.1328e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142619, Final residual = 9.84974e-05, No Iterations 5
time step continuity errors : sum local = 2.45837e-08, global = -2.82234e-09, cumulative = 3.96635e-06
GAMG: Solving for p, Initial residual = 0.00028039, Final residual = 7.15185e-07, No Iterations 15
time step continuity errors : sum local = 1.78523e-10, global = 4.72593e-12, cumulative = 3.96636e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000897845, Final residual = 9.80209e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.002572, Final residual = 5.04908e-06, No Iterations 4
ExecutionTime = 10.21 s ClockTime = 10 s
Time = 0.955
Courant Number mean: 0.107775 max: 0.617149
smoothSolver: Solving for Ux, Initial residual = 0.00099561, Final residual = 2.1203e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015083, Final residual = 5.12225e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00138354, Final residual = 0.00010012, No Iterations 5
time step continuity errors : sum local = 2.49947e-08, global = -2.87507e-09, cumulative = 3.96348e-06
GAMG: Solving for p, Initial residual = 0.000276303, Final residual = 7.19486e-07, No Iterations 15
time step continuity errors : sum local = 1.79633e-10, global = 4.75144e-12, cumulative = 3.96348e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000897184, Final residual = 9.81389e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00256725, Final residual = 5.03678e-06, No Iterations 4
ExecutionTime = 10.23 s ClockTime = 10 s
Time = 0.9575
Courant Number mean: 0.107851 max: 0.617152
smoothSolver: Solving for Ux, Initial residual = 0.000995318, Final residual = 2.11486e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00150976, Final residual = 5.11122e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00139891, Final residual = 9.92231e-05, No Iterations 5
time step continuity errors : sum local = 2.47764e-08, global = -2.86098e-09, cumulative = 3.96062e-06
GAMG: Solving for p, Initial residual = 0.000275254, Final residual = 7.14341e-07, No Iterations 15
time step continuity errors : sum local = 1.78393e-10, global = 4.71298e-12, cumulative = 3.96063e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000896507, Final residual = 9.78601e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00256215, Final residual = 5.02381e-06, No Iterations 4
ExecutionTime = 10.26 s ClockTime = 10 s
Time = 0.96
Courant Number mean: 0.107927 max: 0.617154
smoothSolver: Solving for Ux, Initial residual = 0.000995042, Final residual = 2.1098e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015107, Final residual = 5.10037e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00145137, Final residual = 0.000100194, No Iterations 5
time step continuity errors : sum local = 2.50254e-08, global = -2.8696e-09, cumulative = 3.95776e-06
GAMG: Solving for p, Initial residual = 0.00027729, Final residual = 7.32418e-07, No Iterations 15
time step continuity errors : sum local = 1.8296e-10, global = 4.9345e-12, cumulative = 3.95776e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000895764, Final residual = 9.77635e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00255687, Final residual = 5.00872e-06, No Iterations 4
ExecutionTime = 10.28 s ClockTime = 10 s
Time = 0.9625
Courant Number mean: 0.108002 max: 0.617157
smoothSolver: Solving for Ux, Initial residual = 0.000994802, Final residual = 2.1049e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151143, Final residual = 5.08991e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00141291, Final residual = 9.94574e-05, No Iterations 5
time step continuity errors : sum local = 2.48478e-08, global = -2.86692e-09, cumulative = 3.9549e-06
GAMG: Solving for p, Initial residual = 0.000275736, Final residual = 7.37104e-07, No Iterations 15
time step continuity errors : sum local = 1.84173e-10, global = 4.96947e-12, cumulative = 3.9549e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000895011, Final residual = 9.76506e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00255128, Final residual = 4.99378e-06, No Iterations 4
ExecutionTime = 10.31 s ClockTime = 10 s
Time = 0.965
Courant Number mean: 0.108077 max: 0.61716
smoothSolver: Solving for Ux, Initial residual = 0.00099459, Final residual = 2.09979e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151187, Final residual = 5.07948e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142901, Final residual = 9.93206e-05, No Iterations 5
time step continuity errors : sum local = 2.48206e-08, global = -2.82858e-09, cumulative = 3.95207e-06
GAMG: Solving for p, Initial residual = 0.00027669, Final residual = 7.31129e-07, No Iterations 15
time step continuity errors : sum local = 1.82739e-10, global = 4.944e-12, cumulative = 3.95208e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000894481, Final residual = 9.79429e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00254548, Final residual = 4.98006e-06, No Iterations 4
ExecutionTime = 10.33 s ClockTime = 10 s
Time = 0.9675
Courant Number mean: 0.108151 max: 0.617162
smoothSolver: Solving for Ux, Initial residual = 0.000994383, Final residual = 2.09476e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151178, Final residual = 5.06883e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142434, Final residual = 9.93955e-05, No Iterations 5
time step continuity errors : sum local = 2.48468e-08, global = -2.92734e-09, cumulative = 3.94915e-06
GAMG: Solving for p, Initial residual = 0.000280626, Final residual = 7.2416e-07, No Iterations 15
time step continuity errors : sum local = 1.81047e-10, global = 4.76213e-12, cumulative = 3.94916e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000894031, Final residual = 9.78015e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0025396, Final residual = 4.96467e-06, No Iterations 4
ExecutionTime = 10.35 s ClockTime = 10 s
Time = 0.97
Courant Number mean: 0.108226 max: 0.617164
smoothSolver: Solving for Ux, Initial residual = 0.000994226, Final residual = 2.09001e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151228, Final residual = 5.05871e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.001424, Final residual = 9.95932e-05, No Iterations 5
time step continuity errors : sum local = 2.49045e-08, global = -2.88419e-09, cumulative = 3.94627e-06
GAMG: Solving for p, Initial residual = 0.000278417, Final residual = 7.45716e-07, No Iterations 15
time step continuity errors : sum local = 1.86503e-10, global = 5.06469e-12, cumulative = 3.94628e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000893497, Final residual = 9.7631e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0025341, Final residual = 4.94947e-06, No Iterations 4
ExecutionTime = 10.37 s ClockTime = 10 s
Time = 0.9725
Courant Number mean: 0.1083 max: 0.617167
smoothSolver: Solving for Ux, Initial residual = 0.000994031, Final residual = 2.08459e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151257, Final residual = 5.04786e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00144473, Final residual = 9.97645e-05, No Iterations 5
time step continuity errors : sum local = 2.49566e-08, global = -2.87555e-09, cumulative = 3.9434e-06
GAMG: Solving for p, Initial residual = 0.000279086, Final residual = 7.46109e-07, No Iterations 15
time step continuity errors : sum local = 1.86679e-10, global = 5.0654e-12, cumulative = 3.94341e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000892967, Final residual = 9.75504e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00252836, Final residual = 4.93501e-06, No Iterations 4
ExecutionTime = 10.39 s ClockTime = 10 s
Time = 0.975
Courant Number mean: 0.108376 max: 0.617169
smoothSolver: Solving for Ux, Initial residual = 0.00099385, Final residual = 2.07991e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015128, Final residual = 5.03738e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00150195, Final residual = 9.97089e-05, No Iterations 5
time step continuity errors : sum local = 2.49504e-08, global = -2.89078e-09, cumulative = 3.94052e-06
GAMG: Solving for p, Initial residual = 0.000281118, Final residual = 7.38309e-07, No Iterations 15
time step continuity errors : sum local = 1.84765e-10, global = 4.93476e-12, cumulative = 3.94052e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000892402, Final residual = 9.74823e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00252238, Final residual = 4.91891e-06, No Iterations 4
ExecutionTime = 10.41 s ClockTime = 11 s
Time = 0.9775
Courant Number mean: 0.108452 max: 0.617171
smoothSolver: Solving for Ux, Initial residual = 0.000993636, Final residual = 2.07482e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151302, Final residual = 5.02679e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00146186, Final residual = 9.97753e-05, No Iterations 5
time step continuity errors : sum local = 2.49731e-08, global = -2.879e-09, cumulative = 3.93764e-06
GAMG: Solving for p, Initial residual = 0.000277898, Final residual = 7.4671e-07, No Iterations 15
time step continuity errors : sum local = 1.86922e-10, global = 5.06319e-12, cumulative = 3.93765e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000891871, Final residual = 9.74905e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00251683, Final residual = 4.904e-06, No Iterations 4
ExecutionTime = 10.43 s ClockTime = 11 s
Time = 0.98
Courant Number mean: 0.108529 max: 0.617173
smoothSolver: Solving for Ux, Initial residual = 0.000993403, Final residual = 2.07024e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015134, Final residual = 5.01644e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00147157, Final residual = 9.89358e-05, No Iterations 5
time step continuity errors : sum local = 2.4772e-08, global = -2.83106e-09, cumulative = 3.93482e-06
GAMG: Solving for p, Initial residual = 0.000279205, Final residual = 7.56369e-07, No Iterations 15
time step continuity errors : sum local = 1.89421e-10, global = 5.21584e-12, cumulative = 3.93482e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000891322, Final residual = 9.75773e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00251147, Final residual = 4.88823e-06, No Iterations 4
ExecutionTime = 10.46 s ClockTime = 11 s
Time = 0.9825
Courant Number mean: 0.108606 max: 0.617175
smoothSolver: Solving for Ux, Initial residual = 0.000993162, Final residual = 2.06564e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151443, Final residual = 5.00599e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0014215, Final residual = 9.90877e-05, No Iterations 5
time step continuity errors : sum local = 2.48193e-08, global = -2.83029e-09, cumulative = 3.93199e-06
GAMG: Solving for p, Initial residual = 0.000278684, Final residual = 7.54493e-07, No Iterations 15
time step continuity errors : sum local = 1.8901e-10, global = 5.17747e-12, cumulative = 3.932e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00089077, Final residual = 9.74706e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0025064, Final residual = 4.87572e-06, No Iterations 4
ExecutionTime = 10.48 s ClockTime = 11 s
Time = 0.985
Courant Number mean: 0.108683 max: 0.617177
smoothSolver: Solving for Ux, Initial residual = 0.00099292, Final residual = 2.06094e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151591, Final residual = 4.99557e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00149474, Final residual = 9.86547e-05, No Iterations 5
time step continuity errors : sum local = 2.47187e-08, global = -2.82554e-09, cumulative = 3.92917e-06
GAMG: Solving for p, Initial residual = 0.000280644, Final residual = 7.52786e-07, No Iterations 15
time step continuity errors : sum local = 1.88644e-10, global = 5.14171e-12, cumulative = 3.92918e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000890191, Final residual = 9.73678e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00250141, Final residual = 4.85982e-06, No Iterations 4
ExecutionTime = 10.5 s ClockTime = 11 s
Time = 0.9875
Courant Number mean: 0.10876 max: 0.617179
smoothSolver: Solving for Ux, Initial residual = 0.00099267, Final residual = 2.05628e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151747, Final residual = 4.98441e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00149614, Final residual = 9.83079e-05, No Iterations 5
time step continuity errors : sum local = 2.4641e-08, global = -2.83392e-09, cumulative = 3.92634e-06
GAMG: Solving for p, Initial residual = 0.000287523, Final residual = 7.53608e-07, No Iterations 15
time step continuity errors : sum local = 1.88923e-10, global = 5.17367e-12, cumulative = 3.92635e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000889606, Final residual = 9.73552e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00249671, Final residual = 4.84545e-06, No Iterations 4
ExecutionTime = 10.53 s ClockTime = 11 s
Time = 0.99
Courant Number mean: 0.108837 max: 0.61718
smoothSolver: Solving for Ux, Initial residual = 0.000992415, Final residual = 2.05187e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00151928, Final residual = 4.97436e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00148731, Final residual = 9.94651e-05, No Iterations 5
time step continuity errors : sum local = 2.49364e-08, global = -2.84117e-09, cumulative = 3.92351e-06
GAMG: Solving for p, Initial residual = 0.00028266, Final residual = 7.5319e-07, No Iterations 15
time step continuity errors : sum local = 1.88838e-10, global = 5.1282e-12, cumulative = 3.92351e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000889006, Final residual = 9.73132e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00249201, Final residual = 4.82886e-06, No Iterations 4
ExecutionTime = 10.55 s ClockTime = 11 s
Time = 0.9925
Courant Number mean: 0.108914 max: 0.617182
smoothSolver: Solving for Ux, Initial residual = 0.000992171, Final residual = 2.04748e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152127, Final residual = 4.96557e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0016095, Final residual = 0.000151063, No Iterations 4
time step continuity errors : sum local = 3.7874e-08, global = 4.15897e-09, cumulative = 3.92767e-06
GAMG: Solving for p, Initial residual = 0.000303956, Final residual = 6.16062e-07, No Iterations 16
time step continuity errors : sum local = 1.54457e-10, global = 5.18676e-12, cumulative = 3.92767e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000888345, Final residual = 9.73996e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00248702, Final residual = 4.81583e-06, No Iterations 4
ExecutionTime = 10.58 s ClockTime = 11 s
Time = 0.995
Courant Number mean: 0.108992 max: 0.617184
smoothSolver: Solving for Ux, Initial residual = 0.000991869, Final residual = 2.04061e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152265, Final residual = 4.9579e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00154647, Final residual = 8.39899e-05, No Iterations 5
time step continuity errors : sum local = 2.10581e-08, global = -1.74273e-09, cumulative = 3.92593e-06
GAMG: Solving for p, Initial residual = 0.000280857, Final residual = 7.07753e-07, No Iterations 15
time step continuity errors : sum local = 1.77472e-10, global = 5.28192e-12, cumulative = 3.92594e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00088765, Final residual = 9.73082e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00248191, Final residual = 4.79947e-06, No Iterations 4
ExecutionTime = 10.6 s ClockTime = 11 s
Time = 0.9975
Courant Number mean: 0.109069 max: 0.617185
smoothSolver: Solving for Ux, Initial residual = 0.000991588, Final residual = 2.03687e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152427, Final residual = 4.94472e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00153019, Final residual = 0.000150583, No Iterations 4
time step continuity errors : sum local = 3.77597e-08, global = 4.14342e-09, cumulative = 3.93008e-06
GAMG: Solving for p, Initial residual = 0.000302393, Final residual = 5.91654e-07, No Iterations 16
time step continuity errors : sum local = 1.48375e-10, global = 4.62592e-12, cumulative = 3.93009e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000886927, Final residual = 9.71694e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00247677, Final residual = 4.78419e-06, No Iterations 4
ExecutionTime = 10.62 s ClockTime = 11 s
Time = 1
Courant Number mean: 0.109145 max: 0.617187
smoothSolver: Solving for Ux, Initial residual = 0.000991273, Final residual = 2.03254e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152554, Final residual = 4.94186e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00144349, Final residual = 8.41665e-05, No Iterations 5
time step continuity errors : sum local = 2.11087e-08, global = -1.79995e-09, cumulative = 3.92829e-06
GAMG: Solving for p, Initial residual = 0.000275882, Final residual = 7.09297e-07, No Iterations 15
time step continuity errors : sum local = 1.7792e-10, global = 5.32582e-12, cumulative = 3.92829e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000886316, Final residual = 9.71882e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00247149, Final residual = 4.76832e-06, No Iterations 4
ExecutionTime = 10.68 s ClockTime = 11 s
Time = 1.0025
Courant Number mean: 0.109222 max: 0.617189
smoothSolver: Solving for Ux, Initial residual = 0.00099098, Final residual = 2.02719e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152651, Final residual = 4.92781e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00145394, Final residual = 9.70343e-05, No Iterations 5
time step continuity errors : sum local = 2.43413e-08, global = -2.72082e-09, cumulative = 3.92557e-06
GAMG: Solving for p, Initial residual = 0.000279897, Final residual = 7.26689e-07, No Iterations 15
time step continuity errors : sum local = 1.82308e-10, global = 4.92716e-12, cumulative = 3.92557e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000885783, Final residual = 9.70687e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00246598, Final residual = 4.75345e-06, No Iterations 4
ExecutionTime = 10.71 s ClockTime = 11 s
Time = 1.005
Courant Number mean: 0.109298 max: 0.61719
smoothSolver: Solving for Ux, Initial residual = 0.000990674, Final residual = 2.02589e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015273, Final residual = 4.92222e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00146169, Final residual = 9.86905e-05, No Iterations 5
time step continuity errors : sum local = 2.47624e-08, global = -2.85221e-09, cumulative = 3.92272e-06
GAMG: Solving for p, Initial residual = 0.000280528, Final residual = 7.45988e-07, No Iterations 15
time step continuity errors : sum local = 1.87194e-10, global = 5.05519e-12, cumulative = 3.92273e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000885297, Final residual = 9.71943e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00246034, Final residual = 4.73908e-06, No Iterations 4
ExecutionTime = 10.73 s ClockTime = 11 s
Time = 1.0075
Courant Number mean: 0.109374 max: 0.617192
smoothSolver: Solving for Ux, Initial residual = 0.000990355, Final residual = 2.0198e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152798, Final residual = 4.91298e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00144298, Final residual = 9.89669e-05, No Iterations 5
time step continuity errors : sum local = 2.4837e-08, global = -2.83986e-09, cumulative = 3.91989e-06
GAMG: Solving for p, Initial residual = 0.000281202, Final residual = 7.59335e-07, No Iterations 15
time step continuity errors : sum local = 1.90582e-10, global = 5.27453e-12, cumulative = 3.91989e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000884763, Final residual = 9.72413e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00245498, Final residual = 4.72391e-06, No Iterations 4
ExecutionTime = 10.75 s ClockTime = 11 s
Time = 1.01
Courant Number mean: 0.10945 max: 0.617193
smoothSolver: Solving for Ux, Initial residual = 0.000990032, Final residual = 2.01648e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152878, Final residual = 4.90563e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00149133, Final residual = 0.0001485, No Iterations 4
time step continuity errors : sum local = 3.72761e-08, global = 4.11588e-09, cumulative = 3.92401e-06
GAMG: Solving for p, Initial residual = 0.000303599, Final residual = 6.3161e-07, No Iterations 16
time step continuity errors : sum local = 1.58567e-10, global = 5.38863e-12, cumulative = 3.92401e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00088423, Final residual = 9.71566e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00244939, Final residual = 4.70827e-06, No Iterations 4
ExecutionTime = 10.77 s ClockTime = 11 s
Time = 1.0125
Courant Number mean: 0.109526 max: 0.617194
smoothSolver: Solving for Ux, Initial residual = 0.000989697, Final residual = 2.0095e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00152942, Final residual = 4.90036e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.001487, Final residual = 8.24407e-05, No Iterations 5
time step continuity errors : sum local = 2.06982e-08, global = -1.8219e-09, cumulative = 3.92219e-06
GAMG: Solving for p, Initial residual = 0.000275219, Final residual = 6.95771e-07, No Iterations 15
time step continuity errors : sum local = 1.74718e-10, global = 5.15421e-12, cumulative = 3.9222e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00088362, Final residual = 9.72264e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00244429, Final residual = 4.69425e-06, No Iterations 4
ExecutionTime = 10.79 s ClockTime = 11 s
Time = 1.015
Courant Number mean: 0.109601 max: 0.617196
smoothSolver: Solving for Ux, Initial residual = 0.000989392, Final residual = 2.0057e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00153014, Final residual = 4.88789e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142868, Final residual = 9.72153e-05, No Iterations 5
time step continuity errors : sum local = 2.44149e-08, global = -2.72813e-09, cumulative = 3.91947e-06
GAMG: Solving for p, Initial residual = 0.000280929, Final residual = 7.29403e-07, No Iterations 15
time step continuity errors : sum local = 1.83211e-10, global = 4.98356e-12, cumulative = 3.91947e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00088303, Final residual = 9.736e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0024394, Final residual = 4.67634e-06, No Iterations 4
ExecutionTime = 10.82 s ClockTime = 11 s
Time = 1.0175
Courant Number mean: 0.109676 max: 0.617197
smoothSolver: Solving for Ux, Initial residual = 0.00098908, Final residual = 2.00394e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00153077, Final residual = 4.88219e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00143763, Final residual = 9.88641e-05, No Iterations 5
time step continuity errors : sum local = 2.48363e-08, global = -2.84446e-09, cumulative = 3.91663e-06
GAMG: Solving for p, Initial residual = 0.000282499, Final residual = 7.56668e-07, No Iterations 15
time step continuity errors : sum local = 1.90109e-10, global = 5.24947e-12, cumulative = 3.91663e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000882454, Final residual = 9.71927e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0024346, Final residual = 4.66246e-06, No Iterations 4
ExecutionTime = 10.84 s ClockTime = 11 s
Time = 1.02
Courant Number mean: 0.109751 max: 0.617198
smoothSolver: Solving for Ux, Initial residual = 0.000988784, Final residual = 1.99879e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00153199, Final residual = 4.87417e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142876, Final residual = 0.000100109, No Iterations 5
time step continuity errors : sum local = 2.51556e-08, global = -2.913e-09, cumulative = 3.91372e-06
GAMG: Solving for p, Initial residual = 0.000283389, Final residual = 7.5825e-07, No Iterations 15
time step continuity errors : sum local = 1.90556e-10, global = 5.24228e-12, cumulative = 3.91373e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000881897, Final residual = 9.7097e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0024299, Final residual = 4.64691e-06, No Iterations 4
ExecutionTime = 10.87 s ClockTime = 11 s
Time = 1.0225
Courant Number mean: 0.109826 max: 0.617199
smoothSolver: Solving for Ux, Initial residual = 0.000988545, Final residual = 1.99535e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00153365, Final residual = 4.86777e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00142164, Final residual = 0.00010029, No Iterations 5
time step continuity errors : sum local = 2.52075e-08, global = -2.92099e-09, cumulative = 3.91081e-06
GAMG: Solving for p, Initial residual = 0.000282605, Final residual = 7.57214e-07, No Iterations 15
time step continuity errors : sum local = 1.90341e-10, global = 5.23398e-12, cumulative = 3.91081e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000881365, Final residual = 9.69639e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00242535, Final residual = 4.63208e-06, No Iterations 4
ExecutionTime = 10.89 s ClockTime = 11 s
Time = 1.025
Courant Number mean: 0.1099 max: 0.6172
smoothSolver: Solving for Ux, Initial residual = 0.000988298, Final residual = 1.99095e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00153532, Final residual = 4.86104e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00146579, Final residual = 0.00010039, No Iterations 5
time step continuity errors : sum local = 2.5239e-08, global = -2.92972e-09, cumulative = 3.90788e-06
GAMG: Solving for p, Initial residual = 0.000283159, Final residual = 7.52892e-07, No Iterations 15
time step continuity errors : sum local = 1.89306e-10, global = 5.21417e-12, cumulative = 3.90789e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000880836, Final residual = 9.68828e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00242099, Final residual = 4.61561e-06, No Iterations 4
ExecutionTime = 10.91 s ClockTime = 11 s
Time = 1.0275
Courant Number mean: 0.109974 max: 0.617201
smoothSolver: Solving for Ux, Initial residual = 0.00098809, Final residual = 1.98718e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00153685, Final residual = 4.85425e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00153254, Final residual = 0.000151174, No Iterations 4
time step continuity errors : sum local = 3.80184e-08, global = 4.14481e-09, cumulative = 3.91203e-06
GAMG: Solving for p, Initial residual = 0.000308734, Final residual = 5.76033e-07, No Iterations 16
time step continuity errors : sum local = 1.44899e-10, global = 4.33924e-12, cumulative = 3.91204e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000880313, Final residual = 9.68357e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00241635, Final residual = 4.5995e-06, No Iterations 4
ExecutionTime = 10.93 s ClockTime = 11 s
Time = 1.03
Courant Number mean: 0.110048 max: 0.617202
smoothSolver: Solving for Ux, Initial residual = 0.000987814, Final residual = 1.98035e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00153882, Final residual = 4.85098e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00151546, Final residual = 0.000147791, No Iterations 4
time step continuity errors : sum local = 3.7179e-08, global = 3.54821e-09, cumulative = 3.91558e-06
GAMG: Solving for p, Initial residual = 0.000310809, Final residual = 5.33708e-07, No Iterations 16
time step continuity errors : sum local = 1.34287e-10, global = 4.00299e-12, cumulative = 3.91559e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000879786, Final residual = 9.68016e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00241163, Final residual = 4.58385e-06, No Iterations 4
ExecutionTime = 10.96 s ClockTime = 11 s
Time = 1.0325
Courant Number mean: 0.110122 max: 0.617203
smoothSolver: Solving for Ux, Initial residual = 0.000987603, Final residual = 1.97835e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154082, Final residual = 4.84487e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00143965, Final residual = 8.0871e-05, No Iterations 5
time step continuity errors : sum local = 2.03502e-08, global = -1.80658e-09, cumulative = 3.91378e-06
GAMG: Solving for p, Initial residual = 0.000274026, Final residual = 6.8431e-07, No Iterations 15
time step continuity errors : sum local = 1.72231e-10, global = 5.17809e-12, cumulative = 3.91379e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000879227, Final residual = 9.68802e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00240673, Final residual = 4.56954e-06, No Iterations 4
ExecutionTime = 10.98 s ClockTime = 11 s
Time = 1.035
Courant Number mean: 0.110195 max: 0.617204
smoothSolver: Solving for Ux, Initial residual = 0.000987332, Final residual = 1.97213e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154241, Final residual = 4.83398e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00151534, Final residual = 0.000148852, No Iterations 4
time step continuity errors : sum local = 3.74673e-08, global = 4.06396e-09, cumulative = 3.91785e-06
GAMG: Solving for p, Initial residual = 0.000306589, Final residual = 6.1866e-07, No Iterations 16
time step continuity errors : sum local = 1.55747e-10, global = 4.99624e-12, cumulative = 3.91786e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000878665, Final residual = 9.67959e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00240174, Final residual = 4.55327e-06, No Iterations 4
ExecutionTime = 11 s ClockTime = 11 s
Time = 1.0375
Courant Number mean: 0.110268 max: 0.617205
smoothSolver: Solving for Ux, Initial residual = 0.00098703, Final residual = 1.971e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154416, Final residual = 4.83376e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00152431, Final residual = 7.98675e-05, No Iterations 5
time step continuity errors : sum local = 2.01096e-08, global = -1.73439e-09, cumulative = 3.91612e-06
GAMG: Solving for p, Initial residual = 0.000278065, Final residual = 7.01073e-07, No Iterations 15
time step continuity errors : sum local = 1.7656e-10, global = 5.43631e-12, cumulative = 3.91613e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00087816, Final residual = 9.66816e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00239663, Final residual = 4.53851e-06, No Iterations 4
ExecutionTime = 11.02 s ClockTime = 11 s
Time = 1.04
Courant Number mean: 0.110341 max: 0.617206
smoothSolver: Solving for Ux, Initial residual = 0.000986723, Final residual = 1.96352e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154566, Final residual = 4.82126e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00150076, Final residual = 9.87672e-05, No Iterations 5
time step continuity errors : sum local = 2.48779e-08, global = -2.78387e-09, cumulative = 3.91334e-06
GAMG: Solving for p, Initial residual = 0.000286562, Final residual = 7.19631e-07, No Iterations 15
time step continuity errors : sum local = 1.81302e-10, global = 4.99533e-12, cumulative = 3.91335e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000877693, Final residual = 9.66789e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00239134, Final residual = 4.52247e-06, No Iterations 4
ExecutionTime = 11.04 s ClockTime = 11 s
Time = 1.0425
Courant Number mean: 0.110415 max: 0.617207
smoothSolver: Solving for Ux, Initial residual = 0.000986434, Final residual = 1.96517e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154754, Final residual = 4.81988e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00150821, Final residual = 0.000141511, No Iterations 4
time step continuity errors : sum local = 3.56607e-08, global = 3.77953e-09, cumulative = 3.91713e-06
GAMG: Solving for p, Initial residual = 0.000299644, Final residual = 6.21606e-07, No Iterations 16
time step continuity errors : sum local = 1.56682e-10, global = 5.48242e-12, cumulative = 3.91713e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000877325, Final residual = 9.68026e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00238605, Final residual = 4.50463e-06, No Iterations 4
ExecutionTime = 11.06 s ClockTime = 11 s
Time = 1.045
Courant Number mean: 0.110491 max: 0.617207
smoothSolver: Solving for Ux, Initial residual = 0.000986036, Final residual = 1.95632e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154847, Final residual = 4.81415e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0014976, Final residual = 8.57553e-05, No Iterations 5
time step continuity errors : sum local = 2.16171e-08, global = -2.14661e-09, cumulative = 3.91499e-06
GAMG: Solving for p, Initial residual = 0.000281256, Final residual = 6.74413e-07, No Iterations 15
time step continuity errors : sum local = 1.70034e-10, global = 4.82013e-12, cumulative = 3.91499e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000876922, Final residual = 9.67422e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00238067, Final residual = 4.49314e-06, No Iterations 4
ExecutionTime = 11.08 s ClockTime = 11 s
Time = 1.0475
Courant Number mean: 0.110567 max: 0.617208
smoothSolver: Solving for Ux, Initial residual = 0.000985741, Final residual = 1.95593e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00154984, Final residual = 4.80642e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00149242, Final residual = 0.000145464, No Iterations 4
time step continuity errors : sum local = 3.66806e-08, global = 3.9311e-09, cumulative = 3.91892e-06
GAMG: Solving for p, Initial residual = 0.000303419, Final residual = 5.99628e-07, No Iterations 16
time step continuity errors : sum local = 1.51233e-10, global = 4.87765e-12, cumulative = 3.91893e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000876413, Final residual = 9.67864e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00237575, Final residual = 4.47735e-06, No Iterations 4
ExecutionTime = 11.1 s ClockTime = 11 s
Time = 1.05
Courant Number mean: 0.110643 max: 0.617208
smoothSolver: Solving for Ux, Initial residual = 0.000985384, Final residual = 1.94933e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155112, Final residual = 4.80391e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00150141, Final residual = 0.000148196, No Iterations 4
time step continuity errors : sum local = 3.73814e-08, global = 3.4484e-09, cumulative = 3.92238e-06
GAMG: Solving for p, Initial residual = 0.00031246, Final residual = 5.10763e-07, No Iterations 16
time step continuity errors : sum local = 1.28867e-10, global = 3.75349e-12, cumulative = 3.92238e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000875918, Final residual = 9.66243e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0023712, Final residual = 4.46374e-06, No Iterations 4
ExecutionTime = 11.12 s ClockTime = 11 s
Time = 1.0525
Courant Number mean: 0.11072 max: 0.617209
smoothSolver: Solving for Ux, Initial residual = 0.000985067, Final residual = 1.9467e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155227, Final residual = 4.79763e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00160733, Final residual = 0.000147968, No Iterations 4
time step continuity errors : sum local = 3.73389e-08, global = 3.4621e-09, cumulative = 3.92584e-06
GAMG: Solving for p, Initial residual = 0.000315489, Final residual = 4.99886e-07, No Iterations 16
time step continuity errors : sum local = 1.26176e-10, global = 3.68267e-12, cumulative = 3.92585e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000875501, Final residual = 9.64955e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00236683, Final residual = 4.44811e-06, No Iterations 4
ExecutionTime = 11.14 s ClockTime = 11 s
Time = 1.055
Courant Number mean: 0.110796 max: 0.617209
smoothSolver: Solving for Ux, Initial residual = 0.000984727, Final residual = 1.94257e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155324, Final residual = 4.79176e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.001628, Final residual = 0.000144133, No Iterations 4
time step continuity errors : sum local = 3.63825e-08, global = 3.55875e-09, cumulative = 3.9294e-06
GAMG: Solving for p, Initial residual = 0.000320022, Final residual = 5.01666e-07, No Iterations 16
time step continuity errors : sum local = 1.26655e-10, global = 3.68517e-12, cumulative = 3.92941e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00087509, Final residual = 9.65932e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00236251, Final residual = 4.4325e-06, No Iterations 4
ExecutionTime = 11.17 s ClockTime = 11 s
Time = 1.0575
Courant Number mean: 0.110873 max: 0.617209
smoothSolver: Solving for Ux, Initial residual = 0.000984361, Final residual = 1.93918e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155459, Final residual = 4.78514e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00149714, Final residual = 0.000144048, No Iterations 4
time step continuity errors : sum local = 3.63704e-08, global = 3.63494e-09, cumulative = 3.93304e-06
GAMG: Solving for p, Initial residual = 0.000309468, Final residual = 6.34987e-07, No Iterations 16
time step continuity errors : sum local = 1.60353e-10, global = 5.99461e-12, cumulative = 3.93305e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000874669, Final residual = 9.65064e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00235833, Final residual = 4.419e-06, No Iterations 4
ExecutionTime = 11.19 s ClockTime = 11 s
Time = 1.06
Courant Number mean: 0.11095 max: 0.617209
smoothSolver: Solving for Ux, Initial residual = 0.000984002, Final residual = 1.93717e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155628, Final residual = 4.78021e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00160439, Final residual = 0.000144891, No Iterations 4
time step continuity errors : sum local = 3.65867e-08, global = 3.39318e-09, cumulative = 3.93644e-06
GAMG: Solving for p, Initial residual = 0.000314157, Final residual = 5.13108e-07, No Iterations 16
time step continuity errors : sum local = 1.29569e-10, global = 3.87213e-12, cumulative = 3.93645e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000874213, Final residual = 9.66047e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00235422, Final residual = 4.40252e-06, No Iterations 4
ExecutionTime = 11.21 s ClockTime = 11 s
Time = 1.0625
Courant Number mean: 0.111027 max: 0.617209
smoothSolver: Solving for Ux, Initial residual = 0.000983618, Final residual = 1.93143e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155812, Final residual = 4.77344e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00164273, Final residual = 0.00015095, No Iterations 4
time step continuity errors : sum local = 3.81161e-08, global = 3.46551e-09, cumulative = 3.93991e-06
GAMG: Solving for p, Initial residual = 0.00031851, Final residual = 5.04456e-07, No Iterations 16
time step continuity errors : sum local = 1.27388e-10, global = 3.79449e-12, cumulative = 3.93991e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000873728, Final residual = 9.65422e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0023501, Final residual = 4.38709e-06, No Iterations 4
ExecutionTime = 11.23 s ClockTime = 11 s
Time = 1.065
Courant Number mean: 0.111103 max: 0.617209
smoothSolver: Solving for Ux, Initial residual = 0.000983271, Final residual = 1.92861e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00155984, Final residual = 4.76902e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00160104, Final residual = 0.000136612, No Iterations 4
time step continuity errors : sum local = 3.44992e-08, global = 3.46796e-09, cumulative = 3.94338e-06
GAMG: Solving for p, Initial residual = 0.00030957, Final residual = 6.95511e-07, No Iterations 16
time step continuity errors : sum local = 1.75661e-10, global = 7.19292e-12, cumulative = 3.94339e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000873207, Final residual = 9.62872e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00234563, Final residual = 4.37202e-06, No Iterations 4
ExecutionTime = 11.25 s ClockTime = 11 s
Time = 1.0675
Courant Number mean: 0.111179 max: 0.617209
smoothSolver: Solving for Ux, Initial residual = 0.000982937, Final residual = 1.92721e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015619, Final residual = 4.76595e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00149095, Final residual = 0.000138871, No Iterations 4
time step continuity errors : sum local = 3.50764e-08, global = 3.56242e-09, cumulative = 3.94695e-06
GAMG: Solving for p, Initial residual = 0.000307156, Final residual = 5.86826e-07, No Iterations 16
time step continuity errors : sum local = 1.48244e-10, global = 4.96856e-12, cumulative = 3.94696e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000872627, Final residual = 9.62932e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00234097, Final residual = 4.35636e-06, No Iterations 4
ExecutionTime = 11.28 s ClockTime = 11 s
Time = 1.07
Courant Number mean: 0.111255 max: 0.617209
smoothSolver: Solving for Ux, Initial residual = 0.000982574, Final residual = 1.9212e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00156368, Final residual = 4.75986e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00152953, Final residual = 0.000137828, No Iterations 4
time step continuity errors : sum local = 3.48209e-08, global = 3.55084e-09, cumulative = 3.95051e-06
GAMG: Solving for p, Initial residual = 0.00030785, Final residual = 6.56389e-07, No Iterations 16
time step continuity errors : sum local = 1.6586e-10, global = 6.56878e-12, cumulative = 3.95051e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000872041, Final residual = 9.63617e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00233625, Final residual = 4.3408e-06, No Iterations 4
ExecutionTime = 11.3 s ClockTime = 11 s
Time = 1.0725
Courant Number mean: 0.111331 max: 0.617209
smoothSolver: Solving for Ux, Initial residual = 0.000982229, Final residual = 1.92007e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00156522, Final residual = 4.75618e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00154542, Final residual = 0.000141616, No Iterations 4
time step continuity errors : sum local = 3.57858e-08, global = 3.65932e-09, cumulative = 3.95417e-06
GAMG: Solving for p, Initial residual = 0.000317102, Final residual = 6.24653e-07, No Iterations 16
time step continuity errors : sum local = 1.57872e-10, global = 5.40656e-12, cumulative = 3.95418e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000871537, Final residual = 9.65142e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00233153, Final residual = 4.32644e-06, No Iterations 4
ExecutionTime = 11.33 s ClockTime = 11 s
Time = 1.075
Courant Number mean: 0.111406 max: 0.617209
smoothSolver: Solving for Ux, Initial residual = 0.000981883, Final residual = 1.91489e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015673, Final residual = 4.75162e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0014918, Final residual = 0.000138443, No Iterations 4
time step continuity errors : sum local = 3.49922e-08, global = 3.57773e-09, cumulative = 3.95776e-06
GAMG: Solving for p, Initial residual = 0.000309027, Final residual = 6.55972e-07, No Iterations 16
time step continuity errors : sum local = 1.65828e-10, global = 6.37486e-12, cumulative = 3.95776e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000871076, Final residual = 9.63807e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00232674, Final residual = 4.31434e-06, No Iterations 4
ExecutionTime = 11.35 s ClockTime = 11 s
Time = 1.0775
Courant Number mean: 0.111481 max: 0.617208
smoothSolver: Solving for Ux, Initial residual = 0.000981564, Final residual = 1.91251e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00156876, Final residual = 4.74772e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00149748, Final residual = 0.000137392, No Iterations 4
time step continuity errors : sum local = 3.47359e-08, global = 3.55824e-09, cumulative = 3.96132e-06
GAMG: Solving for p, Initial residual = 0.000307346, Final residual = 6.55567e-07, No Iterations 16
time step continuity errors : sum local = 1.65773e-10, global = 6.38644e-12, cumulative = 3.96133e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000870605, Final residual = 9.63277e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00232183, Final residual = 4.29907e-06, No Iterations 4
ExecutionTime = 11.37 s ClockTime = 11 s
Time = 1.08
Courant Number mean: 0.111555 max: 0.617208
smoothSolver: Solving for Ux, Initial residual = 0.000981251, Final residual = 1.90851e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00156998, Final residual = 4.74309e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00150267, Final residual = 0.000137155, No Iterations 4
time step continuity errors : sum local = 3.46868e-08, global = 3.54467e-09, cumulative = 3.96487e-06
GAMG: Solving for p, Initial residual = 0.000308128, Final residual = 6.68795e-07, No Iterations 16
time step continuity errors : sum local = 1.69179e-10, global = 6.72384e-12, cumulative = 3.96488e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000870137, Final residual = 9.65578e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00231688, Final residual = 4.28265e-06, No Iterations 4
ExecutionTime = 11.39 s ClockTime = 11 s
Time = 1.0825
Courant Number mean: 0.111629 max: 0.617207
smoothSolver: Solving for Ux, Initial residual = 0.000980957, Final residual = 1.90551e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00157097, Final residual = 4.73946e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00155574, Final residual = 0.000136557, No Iterations 4
time step continuity errors : sum local = 3.45499e-08, global = 3.5245e-09, cumulative = 3.9684e-06
GAMG: Solving for p, Initial residual = 0.000308492, Final residual = 6.54595e-07, No Iterations 16
time step continuity errors : sum local = 1.65665e-10, global = 6.39339e-12, cumulative = 3.96841e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00086971, Final residual = 9.64351e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00231224, Final residual = 4.26982e-06, No Iterations 4
ExecutionTime = 11.41 s ClockTime = 12 s
Time = 1.085
Courant Number mean: 0.111703 max: 0.617207
smoothSolver: Solving for Ux, Initial residual = 0.000980688, Final residual = 1.90162e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00157204, Final residual = 4.73592e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0015063, Final residual = 0.000135965, No Iterations 4
time step continuity errors : sum local = 3.44133e-08, global = 3.50594e-09, cumulative = 3.97192e-06
GAMG: Solving for p, Initial residual = 0.000307935, Final residual = 6.45938e-07, No Iterations 16
time step continuity errors : sum local = 1.63522e-10, global = 6.18341e-12, cumulative = 3.97192e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000869329, Final residual = 9.63621e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00230794, Final residual = 4.25548e-06, No Iterations 4
ExecutionTime = 11.44 s ClockTime = 12 s
Time = 1.0875
Courant Number mean: 0.111776 max: 0.617206
smoothSolver: Solving for Ux, Initial residual = 0.000980422, Final residual = 1.89836e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00157334, Final residual = 4.73361e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0015699, Final residual = 0.000134846, No Iterations 4
time step continuity errors : sum local = 3.41381e-08, global = 3.48657e-09, cumulative = 3.97541e-06
GAMG: Solving for p, Initial residual = 0.000308647, Final residual = 6.33402e-07, No Iterations 16
time step continuity errors : sum local = 1.60376e-10, global = 5.85533e-12, cumulative = 3.97542e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000868968, Final residual = 9.63093e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00230385, Final residual = 4.24108e-06, No Iterations 4
ExecutionTime = 11.46 s ClockTime = 12 s
Time = 1.09
Courant Number mean: 0.111849 max: 0.617205
smoothSolver: Solving for Ux, Initial residual = 0.00098012, Final residual = 1.89475e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00157473, Final residual = 4.73149e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00154025, Final residual = 0.000134809, No Iterations 4
time step continuity errors : sum local = 3.41349e-08, global = 3.5275e-09, cumulative = 3.97894e-06
GAMG: Solving for p, Initial residual = 0.000308999, Final residual = 6.23764e-07, No Iterations 16
time step continuity errors : sum local = 1.57966e-10, global = 5.51191e-12, cumulative = 3.97895e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000868599, Final residual = 9.62923e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00229978, Final residual = 4.22489e-06, No Iterations 4
ExecutionTime = 11.48 s ClockTime = 12 s
Time = 1.0925
Courant Number mean: 0.111921 max: 0.617205
smoothSolver: Solving for Ux, Initial residual = 0.000979796, Final residual = 1.89149e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00157602, Final residual = 4.73014e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00153192, Final residual = 0.000134239, No Iterations 4
time step continuity errors : sum local = 3.39982e-08, global = 3.47566e-09, cumulative = 3.98242e-06
GAMG: Solving for p, Initial residual = 0.000311576, Final residual = 6.40216e-07, No Iterations 16
time step continuity errors : sum local = 1.62171e-10, global = 6.05683e-12, cumulative = 3.98243e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000868192, Final residual = 9.64329e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0022957, Final residual = 4.21087e-06, No Iterations 4
ExecutionTime = 11.5 s ClockTime = 12 s
Time = 1.095
Courant Number mean: 0.111993 max: 0.617204
smoothSolver: Solving for Ux, Initial residual = 0.000979443, Final residual = 1.8883e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00157723, Final residual = 4.72734e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0015382, Final residual = 0.000134882, No Iterations 4
time step continuity errors : sum local = 3.41691e-08, global = 3.53117e-09, cumulative = 3.98596e-06
GAMG: Solving for p, Initial residual = 0.000309501, Final residual = 6.34289e-07, No Iterations 16
time step continuity errors : sum local = 1.60712e-10, global = 5.77083e-12, cumulative = 3.98597e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000867764, Final residual = 9.62398e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00229169, Final residual = 4.1972e-06, No Iterations 4
ExecutionTime = 11.52 s ClockTime = 12 s
Time = 1.0975
Courant Number mean: 0.112065 max: 0.617203
smoothSolver: Solving for Ux, Initial residual = 0.000979093, Final residual = 1.88534e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00157926, Final residual = 4.72582e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0015078, Final residual = 0.000135265, No Iterations 4
time step continuity errors : sum local = 3.42758e-08, global = 3.55361e-09, cumulative = 3.98952e-06
GAMG: Solving for p, Initial residual = 0.000309355, Final residual = 6.27971e-07, No Iterations 16
time step continuity errors : sum local = 1.59157e-10, global = 5.62708e-12, cumulative = 3.98953e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000867374, Final residual = 9.64935e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00228776, Final residual = 4.18394e-06, No Iterations 4
ExecutionTime = 11.54 s ClockTime = 12 s
Time = 1.1
Courant Number mean: 0.112136 max: 0.617202
smoothSolver: Solving for Ux, Initial residual = 0.000978701, Final residual = 1.88217e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00158186, Final residual = 4.72385e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00149592, Final residual = 0.000134927, No Iterations 4
time step continuity errors : sum local = 3.41998e-08, global = 3.51456e-09, cumulative = 3.99304e-06
GAMG: Solving for p, Initial residual = 0.000308717, Final residual = 6.2408e-07, No Iterations 16
time step continuity errors : sum local = 1.58215e-10, global = 5.53252e-12, cumulative = 3.99305e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000867008, Final residual = 9.63895e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00228361, Final residual = 4.16831e-06, No Iterations 4
ExecutionTime = 11.59 s ClockTime = 12 s
Time = 1.1025
Courant Number mean: 0.112207 max: 0.617202
smoothSolver: Solving for Ux, Initial residual = 0.000978363, Final residual = 1.87938e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00158454, Final residual = 4.72225e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00154698, Final residual = 0.000134041, No Iterations 4
time step continuity errors : sum local = 3.39853e-08, global = 3.49336e-09, cumulative = 3.99654e-06
GAMG: Solving for p, Initial residual = 0.000308904, Final residual = 6.21663e-07, No Iterations 16
time step continuity errors : sum local = 1.57648e-10, global = 5.64969e-12, cumulative = 3.99655e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000866612, Final residual = 9.62012e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00227927, Final residual = 4.15233e-06, No Iterations 4
ExecutionTime = 11.61 s ClockTime = 12 s
Time = 1.105
Courant Number mean: 0.112278 max: 0.617201
smoothSolver: Solving for Ux, Initial residual = 0.000978079, Final residual = 1.87617e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00158695, Final residual = 4.71975e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00156026, Final residual = 0.000136108, No Iterations 4
time step continuity errors : sum local = 3.45192e-08, global = 3.51365e-09, cumulative = 4.00006e-06
GAMG: Solving for p, Initial residual = 0.000312044, Final residual = 6.3244e-07, No Iterations 16
time step continuity errors : sum local = 1.60429e-10, global = 5.60926e-12, cumulative = 4.00006e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000866192, Final residual = 9.61566e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00227486, Final residual = 4.13604e-06, No Iterations 4
ExecutionTime = 11.64 s ClockTime = 12 s
Time = 1.1075
Courant Number mean: 0.112348 max: 0.6172
smoothSolver: Solving for Ux, Initial residual = 0.000977773, Final residual = 1.87334e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00158949, Final residual = 4.718e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00156429, Final residual = 0.000137262, No Iterations 4
time step continuity errors : sum local = 3.48249e-08, global = 3.54995e-09, cumulative = 4.00361e-06
GAMG: Solving for p, Initial residual = 0.000311922, Final residual = 6.21322e-07, No Iterations 16
time step continuity errors : sum local = 1.57679e-10, global = 5.33973e-12, cumulative = 4.00362e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000865747, Final residual = 9.64181e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00227048, Final residual = 4.12275e-06, No Iterations 4
ExecutionTime = 11.66 s ClockTime = 12 s
Time = 1.11
Courant Number mean: 0.11242 max: 0.617199
smoothSolver: Solving for Ux, Initial residual = 0.000977425, Final residual = 1.86998e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00159207, Final residual = 4.71679e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00155562, Final residual = 0.000136305, No Iterations 4
time step continuity errors : sum local = 3.45955e-08, global = 3.51081e-09, cumulative = 4.00713e-06
GAMG: Solving for p, Initial residual = 0.000311398, Final residual = 6.18295e-07, No Iterations 16
time step continuity errors : sum local = 1.56965e-10, global = 5.41749e-12, cumulative = 4.00714e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000865414, Final residual = 9.62578e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00226619, Final residual = 4.11091e-06, No Iterations 4
ExecutionTime = 11.68 s ClockTime = 12 s
Time = 1.1125
Courant Number mean: 0.112493 max: 0.617198
smoothSolver: Solving for Ux, Initial residual = 0.000977066, Final residual = 1.86716e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00159436, Final residual = 4.7148e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00155119, Final residual = 0.000136732, No Iterations 4
time step continuity errors : sum local = 3.47149e-08, global = 3.50951e-09, cumulative = 4.01065e-06
GAMG: Solving for p, Initial residual = 0.000309883, Final residual = 6.16447e-07, No Iterations 16
time step continuity errors : sum local = 1.56541e-10, global = 5.35518e-12, cumulative = 4.01065e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000865176, Final residual = 9.6169e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00226179, Final residual = 4.09631e-06, No Iterations 4
ExecutionTime = 11.7 s ClockTime = 12 s
Time = 1.115
Courant Number mean: 0.112567 max: 0.617197
smoothSolver: Solving for Ux, Initial residual = 0.000976669, Final residual = 1.86419e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0015964, Final residual = 4.71286e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0015431, Final residual = 0.000137834, No Iterations 4
time step continuity errors : sum local = 3.50058e-08, global = 3.50317e-09, cumulative = 4.01415e-06
GAMG: Solving for p, Initial residual = 0.000310229, Final residual = 6.1546e-07, No Iterations 16
time step continuity errors : sum local = 1.56342e-10, global = 5.34753e-12, cumulative = 4.01416e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000864937, Final residual = 9.60179e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00225733, Final residual = 4.08198e-06, No Iterations 4
ExecutionTime = 11.72 s ClockTime = 12 s
Time = 1.1175
Courant Number mean: 0.112642 max: 0.617196
smoothSolver: Solving for Ux, Initial residual = 0.00097628, Final residual = 1.86125e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00159818, Final residual = 4.71069e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00158132, Final residual = 0.000137088, No Iterations 4
time step continuity errors : sum local = 3.48285e-08, global = 3.5054e-09, cumulative = 4.01766e-06
GAMG: Solving for p, Initial residual = 0.000312373, Final residual = 6.18458e-07, No Iterations 16
time step continuity errors : sum local = 1.57164e-10, global = 5.27047e-12, cumulative = 4.01767e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000864695, Final residual = 9.61505e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00225305, Final residual = 4.07003e-06, No Iterations 4
ExecutionTime = 11.75 s ClockTime = 12 s
Time = 1.12
Courant Number mean: 0.112717 max: 0.617195
smoothSolver: Solving for Ux, Initial residual = 0.000975868, Final residual = 1.85811e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00159986, Final residual = 4.709e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00160308, Final residual = 0.000138358, No Iterations 4
time step continuity errors : sum local = 3.51675e-08, global = 3.48418e-09, cumulative = 4.02115e-06
GAMG: Solving for p, Initial residual = 0.000311724, Final residual = 6.20651e-07, No Iterations 16
time step continuity errors : sum local = 1.57805e-10, global = 5.45057e-12, cumulative = 4.02116e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000864474, Final residual = 9.60493e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00224903, Final residual = 4.05894e-06, No Iterations 4
ExecutionTime = 11.77 s ClockTime = 12 s
Time = 1.1225
Courant Number mean: 0.112792 max: 0.617194
smoothSolver: Solving for Ux, Initial residual = 0.000975457, Final residual = 1.85509e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00160119, Final residual = 4.7058e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00164936, Final residual = 0.000139103, No Iterations 4
time step continuity errors : sum local = 3.53738e-08, global = 3.4666e-09, cumulative = 4.02463e-06
GAMG: Solving for p, Initial residual = 0.000316606, Final residual = 6.28548e-07, No Iterations 16
time step continuity errors : sum local = 1.59881e-10, global = 5.52313e-12, cumulative = 4.02463e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000864206, Final residual = 9.62753e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00224519, Final residual = 4.04469e-06, No Iterations 4
ExecutionTime = 11.79 s ClockTime = 12 s
Time = 1.125
Courant Number mean: 0.112867 max: 0.617193
smoothSolver: Solving for Ux, Initial residual = 0.000974991, Final residual = 1.85219e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00160292, Final residual = 4.70367e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00155082, Final residual = 0.000139872, No Iterations 4
time step continuity errors : sum local = 3.55828e-08, global = 3.46795e-09, cumulative = 4.0281e-06
GAMG: Solving for p, Initial residual = 0.000312613, Final residual = 6.19286e-07, No Iterations 16
time step continuity errors : sum local = 1.57577e-10, global = 5.32637e-12, cumulative = 4.0281e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000863878, Final residual = 9.63332e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00224157, Final residual = 4.02825e-06, No Iterations 4
ExecutionTime = 11.81 s ClockTime = 12 s
Time = 1.1275
Courant Number mean: 0.112942 max: 0.617192
smoothSolver: Solving for Ux, Initial residual = 0.000974545, Final residual = 1.84908e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00160441, Final residual = 4.70136e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0017701, Final residual = 0.000140702, No Iterations 4
time step continuity errors : sum local = 3.57977e-08, global = 3.44818e-09, cumulative = 4.03155e-06
GAMG: Solving for p, Initial residual = 0.000319991, Final residual = 6.21172e-07, No Iterations 16
time step continuity errors : sum local = 1.58038e-10, global = 5.41367e-12, cumulative = 4.03156e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000863542, Final residual = 9.62128e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00223788, Final residual = 4.0144e-06, No Iterations 4
ExecutionTime = 11.84 s ClockTime = 12 s
Time = 1.13
Courant Number mean: 0.113017 max: 0.617191
smoothSolver: Solving for Ux, Initial residual = 0.000974118, Final residual = 1.84621e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00160576, Final residual = 4.70014e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00172302, Final residual = 0.000141186, No Iterations 4
time step continuity errors : sum local = 3.59213e-08, global = 3.44083e-09, cumulative = 4.035e-06
GAMG: Solving for p, Initial residual = 0.000320233, Final residual = 6.26048e-07, No Iterations 16
time step continuity errors : sum local = 1.59298e-10, global = 5.43856e-12, cumulative = 4.035e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000863157, Final residual = 9.60801e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00223421, Final residual = 3.99989e-06, No Iterations 4
ExecutionTime = 11.86 s ClockTime = 12 s
Time = 1.1325
Courant Number mean: 0.113091 max: 0.617189
smoothSolver: Solving for Ux, Initial residual = 0.000973718, Final residual = 1.84341e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0016069, Final residual = 4.69872e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0017082, Final residual = 0.000142319, No Iterations 4
time step continuity errors : sum local = 3.62111e-08, global = 3.42562e-09, cumulative = 4.03843e-06
GAMG: Solving for p, Initial residual = 0.000320555, Final residual = 6.31609e-07, No Iterations 16
time step continuity errors : sum local = 1.60716e-10, global = 5.5191e-12, cumulative = 4.03844e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000862777, Final residual = 9.62414e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00223044, Final residual = 3.98657e-06, No Iterations 4
ExecutionTime = 11.88 s ClockTime = 12 s
Time = 1.135
Courant Number mean: 0.113166 max: 0.617188
smoothSolver: Solving for Ux, Initial residual = 0.000973316, Final residual = 1.84071e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00160796, Final residual = 4.69785e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00161398, Final residual = 0.000143442, No Iterations 4
time step continuity errors : sum local = 3.65025e-08, global = 3.41365e-09, cumulative = 4.04185e-06
GAMG: Solving for p, Initial residual = 0.000317159, Final residual = 6.30497e-07, No Iterations 16
time step continuity errors : sum local = 1.60477e-10, global = 5.51572e-12, cumulative = 4.04186e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000862411, Final residual = 9.6158e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00222661, Final residual = 3.97337e-06, No Iterations 4
ExecutionTime = 11.9 s ClockTime = 12 s
Time = 1.1375
Courant Number mean: 0.113239 max: 0.617187
smoothSolver: Solving for Ux, Initial residual = 0.000972968, Final residual = 1.83803e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00160914, Final residual = 4.69733e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00156718, Final residual = 0.000143918, No Iterations 4
time step continuity errors : sum local = 3.66341e-08, global = 3.42039e-09, cumulative = 4.04528e-06
GAMG: Solving for p, Initial residual = 0.000316389, Final residual = 6.25852e-07, No Iterations 16
time step continuity errors : sum local = 1.59343e-10, global = 5.45585e-12, cumulative = 4.04528e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000862094, Final residual = 9.60911e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0022228, Final residual = 3.96023e-06, No Iterations 4
ExecutionTime = 11.93 s ClockTime = 12 s
Time = 1.14
Courant Number mean: 0.113313 max: 0.617186
smoothSolver: Solving for Ux, Initial residual = 0.000972663, Final residual = 1.83524e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00161072, Final residual = 4.69672e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0015844, Final residual = 0.000144876, No Iterations 4
time step continuity errors : sum local = 3.68876e-08, global = 3.39927e-09, cumulative = 4.04868e-06
GAMG: Solving for p, Initial residual = 0.000317938, Final residual = 6.25577e-07, No Iterations 16
time step continuity errors : sum local = 1.59308e-10, global = 5.49644e-12, cumulative = 4.04869e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000861804, Final residual = 9.64298e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00221898, Final residual = 3.94893e-06, No Iterations 4
ExecutionTime = 11.95 s ClockTime = 12 s
Time = 1.1425
Courant Number mean: 0.113386 max: 0.617185
smoothSolver: Solving for Ux, Initial residual = 0.000972369, Final residual = 1.83265e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00161249, Final residual = 4.69603e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00164413, Final residual = 0.000148112, No Iterations 4
time step continuity errors : sum local = 3.77189e-08, global = 3.38209e-09, cumulative = 4.05207e-06
GAMG: Solving for p, Initial residual = 0.000324485, Final residual = 6.31078e-07, No Iterations 16
time step continuity errors : sum local = 1.60738e-10, global = 5.28086e-12, cumulative = 4.05207e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000861477, Final residual = 9.63123e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00221499, Final residual = 3.93669e-06, No Iterations 4
ExecutionTime = 11.97 s ClockTime = 12 s
Time = 1.145
Courant Number mean: 0.113459 max: 0.617184
smoothSolver: Solving for Ux, Initial residual = 0.000972031, Final residual = 1.82995e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00161476, Final residual = 4.69684e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00163152, Final residual = 0.000145797, No Iterations 4
time step continuity errors : sum local = 3.71384e-08, global = 3.3936e-09, cumulative = 4.05547e-06
GAMG: Solving for p, Initial residual = 0.000326848, Final residual = 6.31322e-07, No Iterations 16
time step continuity errors : sum local = 1.60845e-10, global = 5.74199e-12, cumulative = 4.05547e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000861188, Final residual = 9.61792e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00221104, Final residual = 3.92189e-06, No Iterations 4
ExecutionTime = 12 s ClockTime = 12 s
Time = 1.1475
Courant Number mean: 0.113531 max: 0.617183
smoothSolver: Solving for Ux, Initial residual = 0.000971655, Final residual = 1.82701e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0016162, Final residual = 4.69499e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00158086, Final residual = 0.000147495, No Iterations 4
time step continuity errors : sum local = 3.7581e-08, global = 3.36228e-09, cumulative = 4.05883e-06
GAMG: Solving for p, Initial residual = 0.00031971, Final residual = 6.33024e-07, No Iterations 16
time step continuity errors : sum local = 1.61324e-10, global = 5.60002e-12, cumulative = 4.05884e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000860963, Final residual = 9.63566e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00220711, Final residual = 3.90976e-06, No Iterations 4
ExecutionTime = 12.02 s ClockTime = 12 s
Time = 1.15
Courant Number mean: 0.113603 max: 0.617181
smoothSolver: Solving for Ux, Initial residual = 0.0009713, Final residual = 1.82468e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00161843, Final residual = 4.69529e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00159104, Final residual = 0.000146473, No Iterations 4
time step continuity errors : sum local = 3.73291e-08, global = 3.39328e-09, cumulative = 4.06223e-06
GAMG: Solving for p, Initial residual = 0.000320808, Final residual = 6.34476e-07, No Iterations 16
time step continuity errors : sum local = 1.61723e-10, global = 5.4354e-12, cumulative = 4.06224e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000860791, Final residual = 9.62391e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0022031, Final residual = 3.89627e-06, No Iterations 4
ExecutionTime = 12.04 s ClockTime = 12 s
Time = 1.1525
Courant Number mean: 0.113675 max: 0.61718
smoothSolver: Solving for Ux, Initial residual = 0.000970913, Final residual = 1.82183e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00162136, Final residual = 4.69733e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00165496, Final residual = 0.000145847, No Iterations 4
time step continuity errors : sum local = 3.71778e-08, global = 3.35159e-09, cumulative = 4.06559e-06
GAMG: Solving for p, Initial residual = 0.000319918, Final residual = 6.26876e-07, No Iterations 16
time step continuity errors : sum local = 1.59824e-10, global = 5.3989e-12, cumulative = 4.0656e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000860634, Final residual = 9.61759e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00219927, Final residual = 3.88305e-06, No Iterations 4
ExecutionTime = 12.06 s ClockTime = 12 s
Time = 1.155
Courant Number mean: 0.113746 max: 0.617179
smoothSolver: Solving for Ux, Initial residual = 0.000970552, Final residual = 1.81933e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00162414, Final residual = 4.69943e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00163966, Final residual = 0.000154458, No Iterations 4
time step continuity errors : sum local = 3.93846e-08, global = 3.33523e-09, cumulative = 4.06893e-06
GAMG: Solving for p, Initial residual = 0.000331543, Final residual = 6.31312e-07, No Iterations 16
time step continuity errors : sum local = 1.61015e-10, global = 5.58377e-12, cumulative = 4.06894e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000860445, Final residual = 9.60914e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00219561, Final residual = 3.86902e-06, No Iterations 4
ExecutionTime = 12.08 s ClockTime = 12 s
Time = 1.1575
Courant Number mean: 0.113816 max: 0.617178
smoothSolver: Solving for Ux, Initial residual = 0.000970231, Final residual = 1.81642e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0016264, Final residual = 4.70027e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00159194, Final residual = 0.00014774, No Iterations 4
time step continuity errors : sum local = 3.76841e-08, global = 3.30972e-09, cumulative = 4.07225e-06
GAMG: Solving for p, Initial residual = 0.000320015, Final residual = 6.41967e-07, No Iterations 16
time step continuity errors : sum local = 1.63784e-10, global = 5.65695e-12, cumulative = 4.07225e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000860202, Final residual = 9.59873e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00219202, Final residual = 3.85567e-06, No Iterations 4
ExecutionTime = 12.11 s ClockTime = 12 s
Time = 1.16
Courant Number mean: 0.113886 max: 0.617176
smoothSolver: Solving for Ux, Initial residual = 0.000969936, Final residual = 1.81422e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00162885, Final residual = 4.70272e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00160002, Final residual = 0.000149764, No Iterations 4
time step continuity errors : sum local = 3.82124e-08, global = 3.32727e-09, cumulative = 4.07558e-06
GAMG: Solving for p, Initial residual = 0.000322449, Final residual = 6.21005e-07, No Iterations 16
time step continuity errors : sum local = 1.58482e-10, global = 5.38897e-12, cumulative = 4.07558e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000859921, Final residual = 9.62012e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0021886, Final residual = 3.84123e-06, No Iterations 4
ExecutionTime = 12.13 s ClockTime = 12 s
Time = 1.1625
Courant Number mean: 0.113956 max: 0.617175
smoothSolver: Solving for Ux, Initial residual = 0.000969597, Final residual = 1.81096e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00163121, Final residual = 4.70389e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0016101, Final residual = 0.000150507, No Iterations 4
time step continuity errors : sum local = 3.84121e-08, global = 3.32741e-09, cumulative = 4.07891e-06
GAMG: Solving for p, Initial residual = 0.00032374, Final residual = 6.32678e-07, No Iterations 16
time step continuity errors : sum local = 1.61502e-10, global = 5.51334e-12, cumulative = 4.07892e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000859569, Final residual = 9.63531e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00218517, Final residual = 3.83291e-06, No Iterations 4
ExecutionTime = 12.15 s ClockTime = 12 s
Time = 1.165
Courant Number mean: 0.114026 max: 0.617174
smoothSolver: Solving for Ux, Initial residual = 0.000969264, Final residual = 1.80918e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00163348, Final residual = 4.70598e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00157711, Final residual = 0.000151263, No Iterations 4
time step continuity errors : sum local = 3.86143e-08, global = 3.31023e-09, cumulative = 4.08223e-06
GAMG: Solving for p, Initial residual = 0.000321921, Final residual = 6.25644e-07, No Iterations 16
time step continuity errors : sum local = 1.59741e-10, global = 5.43963e-12, cumulative = 4.08223e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000859239, Final residual = 9.64973e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00218178, Final residual = 3.81932e-06, No Iterations 4
ExecutionTime = 12.17 s ClockTime = 12 s
Time = 1.1675
Courant Number mean: 0.114095 max: 0.617172
smoothSolver: Solving for Ux, Initial residual = 0.000968869, Final residual = 1.80648e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00163572, Final residual = 4.70743e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00156748, Final residual = 0.000151708, No Iterations 4
time step continuity errors : sum local = 3.87381e-08, global = 3.32032e-09, cumulative = 4.08555e-06
GAMG: Solving for p, Initial residual = 0.000321387, Final residual = 6.27786e-07, No Iterations 16
time step continuity errors : sum local = 1.60336e-10, global = 5.47984e-12, cumulative = 4.08556e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000859028, Final residual = 9.63925e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00217838, Final residual = 3.80611e-06, No Iterations 4
ExecutionTime = 12.19 s ClockTime = 12 s
Time = 1.17
Courant Number mean: 0.114163 max: 0.617171
smoothSolver: Solving for Ux, Initial residual = 0.000968448, Final residual = 1.80445e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00163774, Final residual = 4.709e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00159253, Final residual = 0.000151698, No Iterations 4
time step continuity errors : sum local = 3.87471e-08, global = 3.2928e-09, cumulative = 4.08885e-06
GAMG: Solving for p, Initial residual = 0.000322173, Final residual = 6.22748e-07, No Iterations 16
time step continuity errors : sum local = 1.59095e-10, global = 5.39576e-12, cumulative = 4.08886e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000858839, Final residual = 9.64616e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00217484, Final residual = 3.79207e-06, No Iterations 4
ExecutionTime = 12.22 s ClockTime = 12 s
Time = 1.1725
Courant Number mean: 0.114231 max: 0.61717
smoothSolver: Solving for Ux, Initial residual = 0.000967984, Final residual = 1.80199e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00163963, Final residual = 4.71032e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00156786, Final residual = 0.000152254, No Iterations 4
time step continuity errors : sum local = 3.8902e-08, global = 3.27254e-09, cumulative = 4.09213e-06
GAMG: Solving for p, Initial residual = 0.000322276, Final residual = 6.28124e-07, No Iterations 16
time step continuity errors : sum local = 1.60531e-10, global = 5.60368e-12, cumulative = 4.09214e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000858641, Final residual = 9.62122e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00217122, Final residual = 3.78128e-06, No Iterations 4
ExecutionTime = 12.24 s ClockTime = 12 s
Time = 1.175
Courant Number mean: 0.114298 max: 0.617168
smoothSolver: Solving for Ux, Initial residual = 0.000967553, Final residual = 1.7999e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0016412, Final residual = 4.71197e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0016148, Final residual = 0.000152299, No Iterations 4
time step continuity errors : sum local = 3.89281e-08, global = 3.26696e-09, cumulative = 4.0954e-06
GAMG: Solving for p, Initial residual = 0.000325001, Final residual = 6.35931e-07, No Iterations 16
time step continuity errors : sum local = 1.62589e-10, global = 5.77067e-12, cumulative = 4.09541e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000858443, Final residual = 9.61545e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00216771, Final residual = 3.76784e-06, No Iterations 4
ExecutionTime = 12.26 s ClockTime = 12 s
Time = 1.1775
Courant Number mean: 0.114368 max: 0.617167
smoothSolver: Solving for Ux, Initial residual = 0.000967091, Final residual = 1.79766e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00164261, Final residual = 4.71349e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00163592, Final residual = 0.000153761, No Iterations 4
time step continuity errors : sum local = 3.93176e-08, global = 3.27806e-09, cumulative = 4.09869e-06
GAMG: Solving for p, Initial residual = 0.000326522, Final residual = 6.20918e-07, No Iterations 16
time step continuity errors : sum local = 1.58814e-10, global = 5.42988e-12, cumulative = 4.09869e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000858247, Final residual = 9.61265e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00216407, Final residual = 3.75458e-06, No Iterations 4
ExecutionTime = 12.28 s ClockTime = 12 s
Time = 1.18
Courant Number mean: 0.114438 max: 0.617165
smoothSolver: Solving for Ux, Initial residual = 0.000966627, Final residual = 1.79546e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00164443, Final residual = 4.71455e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00160918, Final residual = 0.000154603, No Iterations 4
time step continuity errors : sum local = 3.95469e-08, global = 3.26707e-09, cumulative = 4.10196e-06
GAMG: Solving for p, Initial residual = 0.000324322, Final residual = 6.21695e-07, No Iterations 16
time step continuity errors : sum local = 1.59062e-10, global = 5.51172e-12, cumulative = 4.10196e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000858077, Final residual = 9.60829e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0021603, Final residual = 3.74254e-06, No Iterations 4
ExecutionTime = 12.3 s ClockTime = 12 s
Time = 1.1825
Courant Number mean: 0.11451 max: 0.617164
smoothSolver: Solving for Ux, Initial residual = 0.000966238, Final residual = 1.7931e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0016462, Final residual = 4.71577e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00164655, Final residual = 0.000152716, No Iterations 4
time step continuity errors : sum local = 3.90767e-08, global = 3.23424e-09, cumulative = 4.1052e-06
GAMG: Solving for p, Initial residual = 0.000325352, Final residual = 6.25276e-07, No Iterations 16
time step continuity errors : sum local = 1.60032e-10, global = 5.66358e-12, cumulative = 4.1052e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857978, Final residual = 9.606e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0021567, Final residual = 3.73183e-06, No Iterations 4
ExecutionTime = 12.33 s ClockTime = 12 s
Time = 1.185
Courant Number mean: 0.114581 max: 0.617162
smoothSolver: Solving for Ux, Initial residual = 0.000965858, Final residual = 1.79101e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00164797, Final residual = 4.71645e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00175233, Final residual = 0.000156624, No Iterations 4
time step continuity errors : sum local = 4.00936e-08, global = 3.30296e-09, cumulative = 4.10851e-06
GAMG: Solving for p, Initial residual = 0.000338065, Final residual = 6.28858e-07, No Iterations 16
time step continuity errors : sum local = 1.61027e-10, global = 5.52978e-12, cumulative = 4.10851e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00085792, Final residual = 9.63264e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00215308, Final residual = 3.71946e-06, No Iterations 4
ExecutionTime = 12.35 s ClockTime = 12 s
Time = 1.1875
Courant Number mean: 0.114654 max: 0.617161
smoothSolver: Solving for Ux, Initial residual = 0.000965436, Final residual = 1.78809e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00164993, Final residual = 4.71795e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00178097, Final residual = 0.000154396, No Iterations 4
time step continuity errors : sum local = 3.95422e-08, global = 3.35073e-09, cumulative = 4.11186e-06
GAMG: Solving for p, Initial residual = 0.000336771, Final residual = 6.30515e-07, No Iterations 16
time step continuity errors : sum local = 1.61527e-10, global = 5.5014e-12, cumulative = 4.11187e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857867, Final residual = 9.6484e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00214961, Final residual = 3.70891e-06, No Iterations 4
ExecutionTime = 12.37 s ClockTime = 12 s
Time = 1.19
Courant Number mean: 0.114726 max: 0.617159
smoothSolver: Solving for Ux, Initial residual = 0.000964995, Final residual = 1.78584e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00165181, Final residual = 4.71994e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00179451, Final residual = 0.000155136, No Iterations 4
time step continuity errors : sum local = 3.97493e-08, global = 3.26244e-09, cumulative = 4.11513e-06
GAMG: Solving for p, Initial residual = 0.000332786, Final residual = 6.05658e-07, No Iterations 16
time step continuity errors : sum local = 1.55229e-10, global = 5.3241e-12, cumulative = 4.11514e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857827, Final residual = 9.65339e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00214639, Final residual = 3.69701e-06, No Iterations 4
ExecutionTime = 12.39 s ClockTime = 12 s
Time = 1.1925
Courant Number mean: 0.114798 max: 0.617158
smoothSolver: Solving for Ux, Initial residual = 0.000964608, Final residual = 1.78319e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00165344, Final residual = 4.72145e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00176152, Final residual = 0.000154263, No Iterations 4
time step continuity errors : sum local = 3.95454e-08, global = 3.3055e-09, cumulative = 4.11844e-06
GAMG: Solving for p, Initial residual = 0.000332497, Final residual = 6.00557e-07, No Iterations 16
time step continuity errors : sum local = 1.53994e-10, global = 5.24964e-12, cumulative = 4.11845e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857776, Final residual = 9.63988e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00214332, Final residual = 3.68413e-06, No Iterations 4
ExecutionTime = 12.41 s ClockTime = 13 s
Time = 1.195
Courant Number mean: 0.11487 max: 0.617156
smoothSolver: Solving for Ux, Initial residual = 0.000964203, Final residual = 1.78128e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00165475, Final residual = 4.72411e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00189551, Final residual = 0.000160447, No Iterations 4
time step continuity errors : sum local = 4.11337e-08, global = 3.26257e-09, cumulative = 4.12171e-06
GAMG: Solving for p, Initial residual = 0.000346086, Final residual = 5.73667e-07, No Iterations 16
time step continuity errors : sum local = 1.47065e-10, global = 4.65354e-12, cumulative = 4.12171e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00085773, Final residual = 9.64933e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00214015, Final residual = 3.67077e-06, No Iterations 4
ExecutionTime = 12.43 s ClockTime = 13 s
Time = 1.1975
Courant Number mean: 0.114943 max: 0.617154
smoothSolver: Solving for Ux, Initial residual = 0.000963808, Final residual = 1.77805e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00165675, Final residual = 4.72854e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0019409, Final residual = 0.000159011, No Iterations 4
time step continuity errors : sum local = 4.07561e-08, global = 3.28219e-09, cumulative = 4.125e-06
GAMG: Solving for p, Initial residual = 0.000342578, Final residual = 6.13308e-07, No Iterations 16
time step continuity errors : sum local = 1.57185e-10, global = 5.59996e-12, cumulative = 4.125e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857609, Final residual = 9.64796e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.002137, Final residual = 3.65929e-06, No Iterations 4
ExecutionTime = 12.46 s ClockTime = 13 s
Time = 1.2
Courant Number mean: 0.115015 max: 0.617153
smoothSolver: Solving for Ux, Initial residual = 0.000963424, Final residual = 1.77644e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00165794, Final residual = 4.72988e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00173701, Final residual = 0.000157849, No Iterations 4
time step continuity errors : sum local = 4.04532e-08, global = 3.32126e-09, cumulative = 4.12832e-06
GAMG: Solving for p, Initial residual = 0.000331968, Final residual = 5.96166e-07, No Iterations 16
time step continuity errors : sum local = 1.52802e-10, global = 5.08427e-12, cumulative = 4.12833e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00085745, Final residual = 9.632e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0021339, Final residual = 3.64885e-06, No Iterations 4
ExecutionTime = 12.5 s ClockTime = 13 s
Time = 1.2025
Courant Number mean: 0.115086 max: 0.617151
smoothSolver: Solving for Ux, Initial residual = 0.000963074, Final residual = 1.77382e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00165962, Final residual = 4.73229e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00168319, Final residual = 0.000158252, No Iterations 4
time step continuity errors : sum local = 4.05621e-08, global = 3.33466e-09, cumulative = 4.13166e-06
GAMG: Solving for p, Initial residual = 0.000333464, Final residual = 6.03313e-07, No Iterations 16
time step continuity errors : sum local = 1.54664e-10, global = 5.23311e-12, cumulative = 4.13167e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857348, Final residual = 9.62647e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00213084, Final residual = 3.63582e-06, No Iterations 4
ExecutionTime = 12.52 s ClockTime = 13 s
Time = 1.205
Courant Number mean: 0.115157 max: 0.617149
smoothSolver: Solving for Ux, Initial residual = 0.000962696, Final residual = 1.77192e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00166181, Final residual = 4.73482e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00167891, Final residual = 0.000159032, No Iterations 4
time step continuity errors : sum local = 4.07719e-08, global = 3.38382e-09, cumulative = 4.13505e-06
GAMG: Solving for p, Initial residual = 0.000334224, Final residual = 5.91494e-07, No Iterations 16
time step continuity errors : sum local = 1.51678e-10, global = 4.9785e-12, cumulative = 4.13506e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857285, Final residual = 9.61685e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00212764, Final residual = 3.62685e-06, No Iterations 4
ExecutionTime = 12.54 s ClockTime = 13 s
Time = 1.2075
Courant Number mean: 0.115228 max: 0.617147
smoothSolver: Solving for Ux, Initial residual = 0.00096233, Final residual = 1.76964e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00166464, Final residual = 4.7375e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00164697, Final residual = 0.000160579, No Iterations 4
time step continuity errors : sum local = 4.11782e-08, global = 3.24464e-09, cumulative = 4.1383e-06
GAMG: Solving for p, Initial residual = 0.000336638, Final residual = 6.04669e-07, No Iterations 16
time step continuity errors : sum local = 1.55083e-10, global = 5.35706e-12, cumulative = 4.13831e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857212, Final residual = 9.64504e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0021243, Final residual = 3.61503e-06, No Iterations 4
ExecutionTime = 12.56 s ClockTime = 13 s
Time = 1.21
Courant Number mean: 0.115299 max: 0.617146
smoothSolver: Solving for Ux, Initial residual = 0.000961967, Final residual = 1.76811e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00166708, Final residual = 4.7392e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00161039, Final residual = 0.000160896, No Iterations 4
time step continuity errors : sum local = 4.12675e-08, global = 3.32013e-09, cumulative = 4.14163e-06
GAMG: Solving for p, Initial residual = 0.00033194, Final residual = 5.96462e-07, No Iterations 16
time step continuity errors : sum local = 1.53012e-10, global = 5.10835e-12, cumulative = 4.14163e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857107, Final residual = 9.66054e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0021209, Final residual = 3.60496e-06, No Iterations 4
ExecutionTime = 12.59 s ClockTime = 13 s
Time = 1.2125
Courant Number mean: 0.115369 max: 0.617144
smoothSolver: Solving for Ux, Initial residual = 0.000961601, Final residual = 1.76584e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0016696, Final residual = 4.74135e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00164314, Final residual = 0.00015911, No Iterations 4
time step continuity errors : sum local = 4.08179e-08, global = 3.35156e-09, cumulative = 4.14498e-06
GAMG: Solving for p, Initial residual = 0.000331755, Final residual = 6.03548e-07, No Iterations 16
time step continuity errors : sum local = 1.54861e-10, global = 5.19826e-12, cumulative = 4.14499e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857012, Final residual = 9.67692e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00211767, Final residual = 3.59176e-06, No Iterations 4
ExecutionTime = 12.61 s ClockTime = 13 s
Time = 1.215
Courant Number mean: 0.115438 max: 0.617142
smoothSolver: Solving for Ux, Initial residual = 0.000961247, Final residual = 1.76395e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0016719, Final residual = 4.7436e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00166266, Final residual = 0.000161374, No Iterations 4
time step continuity errors : sum local = 4.14075e-08, global = 3.34789e-09, cumulative = 4.14834e-06
GAMG: Solving for p, Initial residual = 0.000334496, Final residual = 5.90014e-07, No Iterations 16
time step continuity errors : sum local = 1.51421e-10, global = 5.00728e-12, cumulative = 4.14834e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856921, Final residual = 9.66948e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00211431, Final residual = 3.57994e-06, No Iterations 4
ExecutionTime = 12.63 s ClockTime = 13 s
Time = 1.2175
Courant Number mean: 0.115507 max: 0.61714
smoothSolver: Solving for Ux, Initial residual = 0.000960857, Final residual = 1.76178e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00167392, Final residual = 4.74626e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00167013, Final residual = 0.000161472, No Iterations 4
time step continuity errors : sum local = 4.14421e-08, global = 3.3697e-09, cumulative = 4.15171e-06
GAMG: Solving for p, Initial residual = 0.000334673, Final residual = 5.95954e-07, No Iterations 16
time step continuity errors : sum local = 1.52983e-10, global = 5.09832e-12, cumulative = 4.15172e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856863, Final residual = 9.67568e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0021109, Final residual = 3.5698e-06, No Iterations 4
ExecutionTime = 12.66 s ClockTime = 13 s
Time = 1.22
Courant Number mean: 0.115576 max: 0.617139
smoothSolver: Solving for Ux, Initial residual = 0.000960478, Final residual = 1.76017e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0016761, Final residual = 4.75087e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00164071, Final residual = 0.000162338, No Iterations 4
time step continuity errors : sum local = 4.16753e-08, global = 3.35433e-09, cumulative = 4.15507e-06
GAMG: Solving for p, Initial residual = 0.000334437, Final residual = 5.84463e-07, No Iterations 16
time step continuity errors : sum local = 1.50074e-10, global = 4.9336e-12, cumulative = 4.15508e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856879, Final residual = 9.67356e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00210749, Final residual = 3.55739e-06, No Iterations 4
ExecutionTime = 12.68 s ClockTime = 13 s
Time = 1.2225
Courant Number mean: 0.115644 max: 0.617137
smoothSolver: Solving for Ux, Initial residual = 0.000960088, Final residual = 1.758e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0016784, Final residual = 4.75552e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00168688, Final residual = 0.00016089, No Iterations 4
time step continuity errors : sum local = 4.13143e-08, global = 3.35352e-09, cumulative = 4.15843e-06
GAMG: Solving for p, Initial residual = 0.0003341, Final residual = 5.80944e-07, No Iterations 16
time step continuity errors : sum local = 1.49208e-10, global = 4.94297e-12, cumulative = 4.15844e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856914, Final residual = 9.67775e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00210424, Final residual = 3.54457e-06, No Iterations 4
ExecutionTime = 12.7 s ClockTime = 13 s
Time = 1.225
Courant Number mean: 0.115712 max: 0.617135
smoothSolver: Solving for Ux, Initial residual = 0.000959701, Final residual = 1.75647e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00168061, Final residual = 4.76041e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00173374, Final residual = 0.000167322, No Iterations 4
time step continuity errors : sum local = 4.29788e-08, global = 3.34718e-09, cumulative = 4.16178e-06
GAMG: Solving for p, Initial residual = 0.000346451, Final residual = 5.84853e-07, No Iterations 16
time step continuity errors : sum local = 1.50265e-10, global = 4.86658e-12, cumulative = 4.16179e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856971, Final residual = 9.67636e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00210116, Final residual = 3.53157e-06, No Iterations 4
ExecutionTime = 12.73 s ClockTime = 13 s
Time = 1.2275
Courant Number mean: 0.11578 max: 0.617133
smoothSolver: Solving for Ux, Initial residual = 0.000959249, Final residual = 1.75413e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00168285, Final residual = 4.76523e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00168583, Final residual = 0.000166053, No Iterations 4
time step continuity errors : sum local = 4.26646e-08, global = 3.40432e-09, cumulative = 4.16519e-06
GAMG: Solving for p, Initial residual = 0.000343864, Final residual = 6.11021e-07, No Iterations 16
time step continuity errors : sum local = 1.57022e-10, global = 5.22224e-12, cumulative = 4.1652e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856947, Final residual = 9.66716e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00209831, Final residual = 3.52458e-06, No Iterations 4
ExecutionTime = 12.75 s ClockTime = 13 s
Time = 1.23
Courant Number mean: 0.115847 max: 0.617132
smoothSolver: Solving for Ux, Initial residual = 0.000958779, Final residual = 1.75218e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00168525, Final residual = 4.77128e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00160526, Final residual = 9.90331e-05, No Iterations 5
time step continuity errors : sum local = 2.54516e-08, global = -2.81362e-09, cumulative = 4.16238e-06
GAMG: Solving for p, Initial residual = 0.000304381, Final residual = 7.57684e-07, No Iterations 15
time step continuity errors : sum local = 1.9476e-10, global = 6.05344e-12, cumulative = 4.16239e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856868, Final residual = 9.66158e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00209545, Final residual = 3.51374e-06, No Iterations 4
ExecutionTime = 12.77 s ClockTime = 13 s
Time = 1.2325
Courant Number mean: 0.115913 max: 0.61713
smoothSolver: Solving for Ux, Initial residual = 0.000958352, Final residual = 1.7523e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00168721, Final residual = 4.77768e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00164915, Final residual = 0.000163138, No Iterations 4
time step continuity errors : sum local = 4.19405e-08, global = 4.07042e-09, cumulative = 4.16646e-06
GAMG: Solving for p, Initial residual = 0.000329661, Final residual = 6.49839e-07, No Iterations 16
time step continuity errors : sum local = 1.67105e-10, global = 5.69799e-12, cumulative = 4.16647e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856758, Final residual = 9.7196e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00209255, Final residual = 3.50131e-06, No Iterations 4
ExecutionTime = 12.79 s ClockTime = 13 s
Time = 1.235
Courant Number mean: 0.115979 max: 0.617128
smoothSolver: Solving for Ux, Initial residual = 0.000957862, Final residual = 1.74738e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00168907, Final residual = 4.78108e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00169297, Final residual = 0.000165838, No Iterations 4
time step continuity errors : sum local = 4.26469e-08, global = 3.33016e-09, cumulative = 4.1698e-06
GAMG: Solving for p, Initial residual = 0.000338431, Final residual = 5.94763e-07, No Iterations 16
time step continuity errors : sum local = 1.52979e-10, global = 5.08967e-12, cumulative = 4.1698e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856637, Final residual = 9.72034e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00208964, Final residual = 3.49248e-06, No Iterations 4
ExecutionTime = 12.81 s ClockTime = 13 s
Time = 1.2375
Courant Number mean: 0.116044 max: 0.617126
smoothSolver: Solving for Ux, Initial residual = 0.000957457, Final residual = 1.74735e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00169083, Final residual = 4.78596e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00164082, Final residual = 9.92822e-05, No Iterations 5
time step continuity errors : sum local = 2.55391e-08, global = -2.80303e-09, cumulative = 4.167e-06
GAMG: Solving for p, Initial residual = 0.000305955, Final residual = 7.50049e-07, No Iterations 15
time step continuity errors : sum local = 1.92977e-10, global = 5.96941e-12, cumulative = 4.167e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856575, Final residual = 9.70063e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00208674, Final residual = 3.48058e-06, No Iterations 4
ExecutionTime = 12.83 s ClockTime = 13 s
Time = 1.24
Courant Number mean: 0.116109 max: 0.617124
smoothSolver: Solving for Ux, Initial residual = 0.00095706, Final residual = 1.74624e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00169281, Final residual = 4.79155e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00162098, Final residual = 0.000108702, No Iterations 5
time step continuity errors : sum local = 2.79711e-08, global = -3.22044e-09, cumulative = 4.16378e-06
GAMG: Solving for p, Initial residual = 0.000311957, Final residual = 7.94872e-07, No Iterations 15
time step continuity errors : sum local = 2.04575e-10, global = 6.15913e-12, cumulative = 4.16379e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00085652, Final residual = 9.69283e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00208386, Final residual = 3.46843e-06, No Iterations 4
ExecutionTime = 12.86 s ClockTime = 13 s
Time = 1.2425
Courant Number mean: 0.116174 max: 0.617122
smoothSolver: Solving for Ux, Initial residual = 0.000956606, Final residual = 1.74439e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00169473, Final residual = 4.79648e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.001656, Final residual = 0.000162507, No Iterations 4
time step continuity errors : sum local = 4.18315e-08, global = 4.05712e-09, cumulative = 4.16785e-06
GAMG: Solving for p, Initial residual = 0.00033093, Final residual = 6.94949e-07, No Iterations 16
time step continuity errors : sum local = 1.78937e-10, global = 6.4449e-12, cumulative = 4.16785e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856463, Final residual = 9.6874e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00208089, Final residual = 3.45715e-06, No Iterations 4
ExecutionTime = 12.89 s ClockTime = 13 s
Time = 1.245
Courant Number mean: 0.11624 max: 0.617121
smoothSolver: Solving for Ux, Initial residual = 0.000956109, Final residual = 1.74096e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0016967, Final residual = 4.80101e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00171646, Final residual = 0.00016894, No Iterations 4
time step continuity errors : sum local = 4.35024e-08, global = 3.36562e-09, cumulative = 4.17122e-06
GAMG: Solving for p, Initial residual = 0.000343343, Final residual = 5.7985e-07, No Iterations 16
time step continuity errors : sum local = 1.49351e-10, global = 4.92741e-12, cumulative = 4.17122e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856427, Final residual = 9.68681e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00207782, Final residual = 3.4459e-06, No Iterations 4
ExecutionTime = 12.91 s ClockTime = 13 s
Time = 1.2475
Courant Number mean: 0.116308 max: 0.617119
smoothSolver: Solving for Ux, Initial residual = 0.00095567, Final residual = 1.73975e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00169852, Final residual = 4.80557e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00175835, Final residual = 0.00016823, No Iterations 4
time step continuity errors : sum local = 4.33343e-08, global = 3.38336e-09, cumulative = 4.17461e-06
GAMG: Solving for p, Initial residual = 0.000344987, Final residual = 5.91716e-07, No Iterations 16
time step continuity errors : sum local = 1.52458e-10, global = 5.06859e-12, cumulative = 4.17461e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856377, Final residual = 9.68768e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00207477, Final residual = 3.43811e-06, No Iterations 4
ExecutionTime = 12.93 s ClockTime = 13 s
Time = 1.25
Courant Number mean: 0.116376 max: 0.617117
smoothSolver: Solving for Ux, Initial residual = 0.000955253, Final residual = 1.73784e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00170029, Final residual = 4.80981e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0017356, Final residual = 0.000171446, No Iterations 4
time step continuity errors : sum local = 4.41787e-08, global = 2.64038e-09, cumulative = 4.17725e-06
GAMG: Solving for p, Initial residual = 0.000349335, Final residual = 4.96984e-07, No Iterations 16
time step continuity errors : sum local = 1.28095e-10, global = 4.35505e-12, cumulative = 4.17726e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856359, Final residual = 9.68721e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00207177, Final residual = 3.43031e-06, No Iterations 4
ExecutionTime = 12.95 s ClockTime = 13 s
Time = 1.2525
Courant Number mean: 0.116445 max: 0.617115
smoothSolver: Solving for Ux, Initial residual = 0.000954849, Final residual = 1.73487e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00170187, Final residual = 4.81443e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00182025, Final residual = 0.000165927, No Iterations 4
time step continuity errors : sum local = 4.27682e-08, global = 3.58441e-09, cumulative = 4.18084e-06
GAMG: Solving for p, Initial residual = 0.000349612, Final residual = 6.34084e-07, No Iterations 16
time step continuity errors : sum local = 1.63475e-10, global = 5.81681e-12, cumulative = 4.18085e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856335, Final residual = 9.69317e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00206869, Final residual = 3.41846e-06, No Iterations 4
ExecutionTime = 12.97 s ClockTime = 13 s
Time = 1.255
Courant Number mean: 0.116514 max: 0.617113
smoothSolver: Solving for Ux, Initial residual = 0.000954465, Final residual = 1.73521e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00170317, Final residual = 4.81999e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00184237, Final residual = 0.000172577, No Iterations 4
time step continuity errors : sum local = 4.44998e-08, global = 2.46301e-09, cumulative = 4.18331e-06
GAMG: Solving for p, Initial residual = 0.000354616, Final residual = 4.76414e-07, No Iterations 16
time step continuity errors : sum local = 1.22881e-10, global = 4.17573e-12, cumulative = 4.18331e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856334, Final residual = 9.73108e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00206561, Final residual = 3.40876e-06, No Iterations 4
ExecutionTime = 12.99 s ClockTime = 13 s
Time = 1.2575
Courant Number mean: 0.116583 max: 0.617112
smoothSolver: Solving for Ux, Initial residual = 0.000953977, Final residual = 1.73033e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00170429, Final residual = 4.82532e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00178402, Final residual = 0.000168157, No Iterations 4
time step continuity errors : sum local = 4.33721e-08, global = 3.40206e-09, cumulative = 4.18672e-06
GAMG: Solving for p, Initial residual = 0.000349248, Final residual = 6.89475e-07, No Iterations 16
time step continuity errors : sum local = 1.77875e-10, global = 7.04963e-12, cumulative = 4.18672e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856411, Final residual = 9.75241e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00206284, Final residual = 3.3982e-06, No Iterations 4
ExecutionTime = 13.02 s ClockTime = 13 s
Time = 1.26
Courant Number mean: 0.116652 max: 0.61711
smoothSolver: Solving for Ux, Initial residual = 0.000953512, Final residual = 1.73281e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0017055, Final residual = 4.83149e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00187332, Final residual = 0.000170601, No Iterations 4
time step continuity errors : sum local = 4.4017e-08, global = 2.54675e-09, cumulative = 4.18927e-06
GAMG: Solving for p, Initial residual = 0.000357875, Final residual = 4.78426e-07, No Iterations 16
time step continuity errors : sum local = 1.23474e-10, global = 4.31261e-12, cumulative = 4.18927e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856502, Final residual = 9.73365e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00206024, Final residual = 3.38666e-06, No Iterations 4
ExecutionTime = 13.04 s ClockTime = 13 s
Time = 1.2625
Courant Number mean: 0.116721 max: 0.617108
smoothSolver: Solving for Ux, Initial residual = 0.000953024, Final residual = 1.72582e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00170751, Final residual = 4.83584e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00197182, Final residual = 0.000164718, No Iterations 4
time step continuity errors : sum local = 4.2501e-08, global = 3.4978e-09, cumulative = 4.19277e-06
GAMG: Solving for p, Initial residual = 0.000356983, Final residual = 7.06359e-07, No Iterations 16
time step continuity errors : sum local = 1.82255e-10, global = 7.47491e-12, cumulative = 4.19278e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856631, Final residual = 9.74647e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00205771, Final residual = 3.37745e-06, No Iterations 4
ExecutionTime = 13.06 s ClockTime = 13 s
Time = 1.265
Courant Number mean: 0.11679 max: 0.617106
smoothSolver: Solving for Ux, Initial residual = 0.000952634, Final residual = 1.73032e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00170996, Final residual = 4.84174e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00190646, Final residual = 0.000172019, No Iterations 4
time step continuity errors : sum local = 4.43771e-08, global = 2.42993e-09, cumulative = 4.19521e-06
GAMG: Solving for p, Initial residual = 0.000359794, Final residual = 4.83791e-07, No Iterations 16
time step continuity errors : sum local = 1.2481e-10, global = 4.27314e-12, cumulative = 4.19521e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856722, Final residual = 9.74037e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00205518, Final residual = 3.3659e-06, No Iterations 4
ExecutionTime = 13.08 s ClockTime = 13 s
Time = 1.2675
Courant Number mean: 0.116859 max: 0.617104
smoothSolver: Solving for Ux, Initial residual = 0.000952196, Final residual = 1.72234e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00171261, Final residual = 4.84685e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00183987, Final residual = 0.00016417, No Iterations 4
time step continuity errors : sum local = 4.23487e-08, global = 3.56972e-09, cumulative = 4.19878e-06
GAMG: Solving for p, Initial residual = 0.000351047, Final residual = 7.26441e-07, No Iterations 16
time step continuity errors : sum local = 1.87413e-10, global = 7.90758e-12, cumulative = 4.19879e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00085678, Final residual = 9.73954e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00205256, Final residual = 3.3544e-06, No Iterations 4
ExecutionTime = 13.1 s ClockTime = 13 s
Time = 1.27
Courant Number mean: 0.116927 max: 0.617103
smoothSolver: Solving for Ux, Initial residual = 0.000951931, Final residual = 1.72694e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0017149, Final residual = 4.85275e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00176527, Final residual = 0.000170807, No Iterations 4
time step continuity errors : sum local = 4.40674e-08, global = 2.43599e-09, cumulative = 4.20123e-06
GAMG: Solving for p, Initial residual = 0.000353139, Final residual = 4.69028e-07, No Iterations 16
time step continuity errors : sum local = 1.21034e-10, global = 4.27399e-12, cumulative = 4.20123e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856806, Final residual = 9.73351e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00204994, Final residual = 3.34816e-06, No Iterations 4
ExecutionTime = 13.12 s ClockTime = 13 s
Time = 1.2725
Courant Number mean: 0.116995 max: 0.617101
smoothSolver: Solving for Ux, Initial residual = 0.000951565, Final residual = 1.71888e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00171693, Final residual = 4.85641e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00172837, Final residual = 0.000159302, No Iterations 4
time step continuity errors : sum local = 4.1105e-08, global = 3.69309e-09, cumulative = 4.20492e-06
GAMG: Solving for p, Initial residual = 0.000344704, Final residual = 7.56505e-07, No Iterations 16
time step continuity errors : sum local = 1.95235e-10, global = 8.46275e-12, cumulative = 4.20493e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856829, Final residual = 9.73258e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00204738, Final residual = 3.33904e-06, No Iterations 4
ExecutionTime = 13.15 s ClockTime = 13 s
Time = 1.275
Courant Number mean: 0.117062 max: 0.617099
smoothSolver: Solving for Ux, Initial residual = 0.000951182, Final residual = 1.72427e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0017192, Final residual = 4.86304e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00173179, Final residual = 0.00016267, No Iterations 4
time step continuity errors : sum local = 4.19825e-08, global = 2.69233e-09, cumulative = 4.20763e-06
GAMG: Solving for p, Initial residual = 0.000348679, Final residual = 4.73003e-07, No Iterations 16
time step continuity errors : sum local = 1.22101e-10, global = 4.38969e-12, cumulative = 4.20763e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00085687, Final residual = 9.78672e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00204467, Final residual = 3.33011e-06, No Iterations 4
ExecutionTime = 13.17 s ClockTime = 13 s
Time = 1.2775
Courant Number mean: 0.11713 max: 0.617097
smoothSolver: Solving for Ux, Initial residual = 0.00095072, Final residual = 1.71499e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00172149, Final residual = 4.86698e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0017344, Final residual = 0.000165709, No Iterations 4
time step continuity errors : sum local = 4.27767e-08, global = 3.67173e-09, cumulative = 4.2113e-06
GAMG: Solving for p, Initial residual = 0.000352294, Final residual = 7.55978e-07, No Iterations 16
time step continuity errors : sum local = 1.95203e-10, global = 8.4309e-12, cumulative = 4.21131e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856934, Final residual = 9.79594e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00204187, Final residual = 3.31784e-06, No Iterations 4
ExecutionTime = 13.19 s ClockTime = 13 s
Time = 1.28
Courant Number mean: 0.117197 max: 0.617095
smoothSolver: Solving for Ux, Initial residual = 0.00095028, Final residual = 1.72156e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00172402, Final residual = 4.87379e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00171977, Final residual = 0.000164303, No Iterations 4
time step continuity errors : sum local = 4.2427e-08, global = 2.61464e-09, cumulative = 4.21392e-06
GAMG: Solving for p, Initial residual = 0.000348865, Final residual = 4.79828e-07, No Iterations 16
time step continuity errors : sum local = 1.23932e-10, global = 4.50064e-12, cumulative = 4.21393e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857051, Final residual = 9.77369e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00203908, Final residual = 3.30645e-06, No Iterations 4
ExecutionTime = 13.21 s ClockTime = 13 s
Time = 1.2825
Courant Number mean: 0.117263 max: 0.617093
smoothSolver: Solving for Ux, Initial residual = 0.000949801, Final residual = 1.71226e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00172634, Final residual = 4.87816e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00175913, Final residual = 0.000160035, No Iterations 4
time step continuity errors : sum local = 4.13315e-08, global = 3.72978e-09, cumulative = 4.21766e-06
GAMG: Solving for p, Initial residual = 0.000346446, Final residual = 7.61683e-07, No Iterations 16
time step continuity errors : sum local = 1.96754e-10, global = 8.72807e-12, cumulative = 4.21767e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857203, Final residual = 9.78852e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00203622, Final residual = 3.29652e-06, No Iterations 4
ExecutionTime = 13.24 s ClockTime = 13 s
Time = 1.285
Courant Number mean: 0.117329 max: 0.617092
smoothSolver: Solving for Ux, Initial residual = 0.000949376, Final residual = 1.71914e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00172882, Final residual = 4.88433e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00170399, Final residual = 0.000162984, No Iterations 4
time step continuity errors : sum local = 4.21028e-08, global = 2.68578e-09, cumulative = 4.22035e-06
GAMG: Solving for p, Initial residual = 0.000349131, Final residual = 4.81054e-07, No Iterations 16
time step continuity errors : sum local = 1.24298e-10, global = 4.51822e-12, cumulative = 4.22036e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857349, Final residual = 9.78107e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00203338, Final residual = 3.28629e-06, No Iterations 4
ExecutionTime = 13.26 s ClockTime = 13 s
Time = 1.2875
Courant Number mean: 0.117394 max: 0.61709
smoothSolver: Solving for Ux, Initial residual = 0.000948894, Final residual = 1.70965e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00173117, Final residual = 4.89011e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00172436, Final residual = 0.000157098, No Iterations 4
time step continuity errors : sum local = 4.05929e-08, global = 3.71628e-09, cumulative = 4.22407e-06
GAMG: Solving for p, Initial residual = 0.000345239, Final residual = 7.57706e-07, No Iterations 16
time step continuity errors : sum local = 1.9584e-10, global = 8.82287e-12, cumulative = 4.22408e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857495, Final residual = 9.79781e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00203051, Final residual = 3.2746e-06, No Iterations 4
ExecutionTime = 13.28 s ClockTime = 13 s
Time = 1.29
Courant Number mean: 0.117459 max: 0.617088
smoothSolver: Solving for Ux, Initial residual = 0.000948448, Final residual = 1.71689e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00173336, Final residual = 4.89842e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00174474, Final residual = 0.000162439, No Iterations 4
time step continuity errors : sum local = 4.19859e-08, global = 2.77971e-09, cumulative = 4.22686e-06
GAMG: Solving for p, Initial residual = 0.000352131, Final residual = 4.88947e-07, No Iterations 16
time step continuity errors : sum local = 1.26409e-10, global = 4.55996e-12, cumulative = 4.22687e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857659, Final residual = 9.80034e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00202781, Final residual = 3.26382e-06, No Iterations 4
ExecutionTime = 13.3 s ClockTime = 13 s
Time = 1.2925
Courant Number mean: 0.117524 max: 0.617086
smoothSolver: Solving for Ux, Initial residual = 0.000947968, Final residual = 1.70706e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00173569, Final residual = 4.90609e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00172172, Final residual = 0.000156539, No Iterations 4
time step continuity errors : sum local = 4.04718e-08, global = 3.77383e-09, cumulative = 4.23064e-06
GAMG: Solving for p, Initial residual = 0.000345082, Final residual = 7.56902e-07, No Iterations 16
time step continuity errors : sum local = 1.95747e-10, global = 8.6888e-12, cumulative = 4.23065e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857817, Final residual = 9.79205e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00202536, Final residual = 3.25988e-06, No Iterations 4
ExecutionTime = 13.32 s ClockTime = 13 s
Time = 1.295
Courant Number mean: 0.117588 max: 0.617084
smoothSolver: Solving for Ux, Initial residual = 0.000947571, Final residual = 1.71396e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00173773, Final residual = 4.91541e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0017048, Final residual = 0.000161902, No Iterations 4
time step continuity errors : sum local = 4.18726e-08, global = 2.84704e-09, cumulative = 4.2335e-06
GAMG: Solving for p, Initial residual = 0.000350926, Final residual = 4.9211e-07, No Iterations 16
time step continuity errors : sum local = 1.27306e-10, global = 4.68563e-12, cumulative = 4.2335e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000857951, Final residual = 9.79541e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00202299, Final residual = 3.24895e-06, No Iterations 4
ExecutionTime = 13.35 s ClockTime = 13 s
Time = 1.2975
Courant Number mean: 0.117652 max: 0.617082
smoothSolver: Solving for Ux, Initial residual = 0.00094713, Final residual = 1.70445e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00173942, Final residual = 4.9224e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00168486, Final residual = 0.000155561, No Iterations 4
time step continuity errors : sum local = 4.02426e-08, global = 3.81484e-09, cumulative = 4.23732e-06
GAMG: Solving for p, Initial residual = 0.000344614, Final residual = 7.74718e-07, No Iterations 16
time step continuity errors : sum local = 2.00466e-10, global = 9.13668e-12, cumulative = 4.23733e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000858136, Final residual = 9.84311e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00202078, Final residual = 3.23846e-06, No Iterations 4
ExecutionTime = 13.37 s ClockTime = 13 s
Time = 1.3
Courant Number mean: 0.117715 max: 0.61708
smoothSolver: Solving for Ux, Initial residual = 0.000946712, Final residual = 1.71163e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.001741, Final residual = 4.93057e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00170676, Final residual = 0.000160974, No Iterations 4
time step continuity errors : sum local = 4.16592e-08, global = 2.88584e-09, cumulative = 4.24021e-06
GAMG: Solving for p, Initial residual = 0.000352008, Final residual = 4.97846e-07, No Iterations 16
time step continuity errors : sum local = 1.28877e-10, global = 4.77459e-12, cumulative = 4.24022e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000858453, Final residual = 9.86081e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00201858, Final residual = 3.23313e-06, No Iterations 4
ExecutionTime = 13.41 s ClockTime = 14 s
Time = 1.3025
Courant Number mean: 0.117777 max: 0.617079
smoothSolver: Solving for Ux, Initial residual = 0.000946213, Final residual = 1.70174e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00174229, Final residual = 4.93801e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00178028, Final residual = 0.000157877, No Iterations 4
time step continuity errors : sum local = 4.08667e-08, global = 3.83652e-09, cumulative = 4.24405e-06
GAMG: Solving for p, Initial residual = 0.000351473, Final residual = 6.01291e-07, No Iterations 16
time step continuity errors : sum local = 1.55685e-10, global = 5.92179e-12, cumulative = 4.24406e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000858778, Final residual = 9.86491e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0020163, Final residual = 3.22111e-06, No Iterations 4
ExecutionTime = 13.44 s ClockTime = 14 s
Time = 1.305
Courant Number mean: 0.117839 max: 0.617077
smoothSolver: Solving for Ux, Initial residual = 0.000945773, Final residual = 1.70651e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00174382, Final residual = 4.94658e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00180305, Final residual = 0.000162277, No Iterations 4
time step continuity errors : sum local = 4.20168e-08, global = 3.00126e-09, cumulative = 4.24706e-06
GAMG: Solving for p, Initial residual = 0.000356684, Final residual = 5.04531e-07, No Iterations 16
time step continuity errors : sum local = 1.30668e-10, global = 4.70344e-12, cumulative = 4.24706e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000859074, Final residual = 9.84935e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00201404, Final residual = 3.2119e-06, No Iterations 4
ExecutionTime = 13.46 s ClockTime = 14 s
Time = 1.3075
Courant Number mean: 0.117901 max: 0.617075
smoothSolver: Solving for Ux, Initial residual = 0.0009453, Final residual = 1.70118e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00174516, Final residual = 4.95447e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00177364, Final residual = 0.000156043, No Iterations 4
time step continuity errors : sum local = 4.04144e-08, global = 3.83065e-09, cumulative = 4.25089e-06
GAMG: Solving for p, Initial residual = 0.000349375, Final residual = 7.12534e-07, No Iterations 16
time step continuity errors : sum local = 1.84596e-10, global = 7.72242e-12, cumulative = 4.2509e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000859369, Final residual = 9.8449e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00201175, Final residual = 3.20181e-06, No Iterations 4
ExecutionTime = 13.48 s ClockTime = 14 s
Time = 1.31
Courant Number mean: 0.117961 max: 0.617073
smoothSolver: Solving for Ux, Initial residual = 0.000944852, Final residual = 1.70499e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00174657, Final residual = 4.96267e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00183353, Final residual = 0.000169909, No Iterations 4
time step continuity errors : sum local = 4.40234e-08, global = 2.75301e-09, cumulative = 4.25366e-06
GAMG: Solving for p, Initial residual = 0.000363973, Final residual = 4.76383e-07, No Iterations 16
time step continuity errors : sum local = 1.23463e-10, global = 4.48956e-12, cumulative = 4.25366e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000859641, Final residual = 9.84206e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00200937, Final residual = 3.19096e-06, No Iterations 4
ExecutionTime = 13.51 s ClockTime = 14 s
Time = 1.3125
Courant Number mean: 0.118024 max: 0.617071
smoothSolver: Solving for Ux, Initial residual = 0.00094439, Final residual = 1.69742e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00174773, Final residual = 4.96967e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00188609, Final residual = 0.000156516, No Iterations 4
time step continuity errors : sum local = 4.05634e-08, global = 3.89383e-09, cumulative = 4.25755e-06
GAMG: Solving for p, Initial residual = 0.000363513, Final residual = 6.006e-07, No Iterations 16
time step continuity errors : sum local = 1.55702e-10, global = 5.66349e-12, cumulative = 4.25756e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000859889, Final residual = 9.84348e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00200691, Final residual = 3.18462e-06, No Iterations 4
ExecutionTime = 13.54 s ClockTime = 14 s
Time = 1.315
Courant Number mean: 0.118089 max: 0.617069
smoothSolver: Solving for Ux, Initial residual = 0.00094391, Final residual = 1.70007e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00174984, Final residual = 4.98054e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00178027, Final residual = 0.000166424, No Iterations 4
time step continuity errors : sum local = 4.31484e-08, global = 2.92017e-09, cumulative = 4.26048e-06
GAMG: Solving for p, Initial residual = 0.000357073, Final residual = 5.13098e-07, No Iterations 16
time step continuity errors : sum local = 1.33062e-10, global = 4.7765e-12, cumulative = 4.26048e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000860112, Final residual = 9.85353e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00200437, Final residual = 3.17679e-06, No Iterations 4
ExecutionTime = 13.56 s ClockTime = 14 s
Time = 1.3175
Courant Number mean: 0.118154 max: 0.617067
smoothSolver: Solving for Ux, Initial residual = 0.000943411, Final residual = 1.69604e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00175163, Final residual = 4.98967e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00179863, Final residual = 0.000164655, No Iterations 4
time step continuity errors : sum local = 4.27e-08, global = 3.48111e-09, cumulative = 4.26397e-06
GAMG: Solving for p, Initial residual = 0.000356283, Final residual = 5.31986e-07, No Iterations 16
time step continuity errors : sum local = 1.37995e-10, global = 4.86705e-12, cumulative = 4.26397e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000860251, Final residual = 9.8585e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00200171, Final residual = 3.16752e-06, No Iterations 4
ExecutionTime = 13.59 s ClockTime = 14 s
Time = 1.32
Courant Number mean: 0.118219 max: 0.617065
smoothSolver: Solving for Ux, Initial residual = 0.000942904, Final residual = 1.69655e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00175385, Final residual = 4.99725e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00179681, Final residual = 0.000167102, No Iterations 4
time step continuity errors : sum local = 4.33433e-08, global = 3.12592e-09, cumulative = 4.2671e-06
GAMG: Solving for p, Initial residual = 0.000357628, Final residual = 5.41053e-07, No Iterations 16
time step continuity errors : sum local = 1.40367e-10, global = 4.97134e-12, cumulative = 4.2671e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000860401, Final residual = 9.91132e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00199906, Final residual = 3.15619e-06, No Iterations 4
ExecutionTime = 13.61 s ClockTime = 14 s
Time = 1.3225
Courant Number mean: 0.118284 max: 0.617063
smoothSolver: Solving for Ux, Initial residual = 0.000942418, Final residual = 1.69434e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00175663, Final residual = 5.00605e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00182988, Final residual = 0.000168401, No Iterations 4
time step continuity errors : sum local = 4.36899e-08, global = 3.22369e-09, cumulative = 4.27033e-06
GAMG: Solving for p, Initial residual = 0.000357534, Final residual = 5.56444e-07, No Iterations 16
time step continuity errors : sum local = 1.44405e-10, global = 5.28931e-12, cumulative = 4.27033e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000860545, Final residual = 9.90331e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00199638, Final residual = 3.14662e-06, No Iterations 4
ExecutionTime = 13.63 s ClockTime = 14 s
Time = 1.325
Courant Number mean: 0.11835 max: 0.617061
smoothSolver: Solving for Ux, Initial residual = 0.000942015, Final residual = 1.69372e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00175917, Final residual = 5.01378e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00181604, Final residual = 0.000170665, No Iterations 4
time step continuity errors : sum local = 4.42912e-08, global = 3.06271e-09, cumulative = 4.27339e-06
GAMG: Solving for p, Initial residual = 0.000358378, Final residual = 5.37806e-07, No Iterations 16
time step continuity errors : sum local = 1.39612e-10, global = 4.97419e-12, cumulative = 4.2734e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000860688, Final residual = 9.92771e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00199376, Final residual = 3.13705e-06, No Iterations 4
ExecutionTime = 13.66 s ClockTime = 14 s
Time = 1.3275
Courant Number mean: 0.118415 max: 0.617059
smoothSolver: Solving for Ux, Initial residual = 0.000941659, Final residual = 1.69241e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0017618, Final residual = 5.02156e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00186475, Final residual = 0.00017228, No Iterations 4
time step continuity errors : sum local = 4.47253e-08, global = 3.14981e-09, cumulative = 4.27655e-06
GAMG: Solving for p, Initial residual = 0.000364123, Final residual = 5.33835e-07, No Iterations 16
time step continuity errors : sum local = 1.3863e-10, global = 4.98028e-12, cumulative = 4.27655e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000860878, Final residual = 9.92568e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00199136, Final residual = 3.12684e-06, No Iterations 4
ExecutionTime = 13.68 s ClockTime = 14 s
Time = 1.33
Courant Number mean: 0.118481 max: 0.617057
smoothSolver: Solving for Ux, Initial residual = 0.00094129, Final residual = 1.69129e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00176417, Final residual = 5.02956e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00186407, Final residual = 0.000173782, No Iterations 4
time step continuity errors : sum local = 4.5124e-08, global = 3.0477e-09, cumulative = 4.2796e-06
GAMG: Solving for p, Initial residual = 0.00035927, Final residual = 5.40175e-07, No Iterations 16
time step continuity errors : sum local = 1.40284e-10, global = 5.03244e-12, cumulative = 4.27961e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000861063, Final residual = 9.9403e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00198913, Final residual = 3.11826e-06, No Iterations 4
ExecutionTime = 13.7 s ClockTime = 14 s
Time = 1.3325
Courant Number mean: 0.118546 max: 0.617055
smoothSolver: Solving for Ux, Initial residual = 0.000940864, Final residual = 1.69059e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0017663, Final residual = 5.0384e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00201865, Final residual = 0.000175889, No Iterations 4
time step continuity errors : sum local = 4.56664e-08, global = 2.98204e-09, cumulative = 4.28259e-06
GAMG: Solving for p, Initial residual = 0.0003631, Final residual = 5.31311e-07, No Iterations 16
time step continuity errors : sum local = 1.37944e-10, global = 4.91997e-12, cumulative = 4.28259e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000861258, Final residual = 9.93074e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00198702, Final residual = 3.11198e-06, No Iterations 4
ExecutionTime = 13.73 s ClockTime = 14 s
Time = 1.335
Courant Number mean: 0.118611 max: 0.617053
smoothSolver: Solving for Ux, Initial residual = 0.000940363, Final residual = 1.68934e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00176821, Final residual = 5.04687e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00196036, Final residual = 0.000177003, No Iterations 4
time step continuity errors : sum local = 4.59471e-08, global = 2.97191e-09, cumulative = 4.28556e-06
GAMG: Solving for p, Initial residual = 0.000369361, Final residual = 5.42468e-07, No Iterations 16
time step continuity errors : sum local = 1.40828e-10, global = 5.0946e-12, cumulative = 4.28557e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000861454, Final residual = 9.93503e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00198507, Final residual = 3.10468e-06, No Iterations 4
ExecutionTime = 13.75 s ClockTime = 14 s
Time = 1.3375
Courant Number mean: 0.118676 max: 0.617051
smoothSolver: Solving for Ux, Initial residual = 0.000939918, Final residual = 1.68856e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00177017, Final residual = 5.05535e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00191076, Final residual = 0.00018051, No Iterations 4
time step continuity errors : sum local = 4.68596e-08, global = 2.76475e-09, cumulative = 4.28833e-06
GAMG: Solving for p, Initial residual = 0.000369418, Final residual = 5.11117e-07, No Iterations 16
time step continuity errors : sum local = 1.32715e-10, global = 4.71053e-12, cumulative = 4.28834e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000861659, Final residual = 9.93488e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.0019831, Final residual = 3.09752e-06, No Iterations 4
ExecutionTime = 13.78 s ClockTime = 14 s
Time = 1.34
Courant Number mean: 0.11874 max: 0.617049
smoothSolver: Solving for Ux, Initial residual = 0.000939466, Final residual = 1.6875e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00177175, Final residual = 5.06293e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00184392, Final residual = 0.000177959, No Iterations 4
time step continuity errors : sum local = 4.62051e-08, global = 3.05143e-09, cumulative = 4.29139e-06
GAMG: Solving for p, Initial residual = 0.00036357, Final residual = 5.52266e-07, No Iterations 16
time step continuity errors : sum local = 1.4342e-10, global = 5.02246e-12, cumulative = 4.2914e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00086198, Final residual = 9.96083e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00198123, Final residual = 3.08992e-06, No Iterations 4
ExecutionTime = 13.79 s ClockTime = 14 s
Time = 1.3425
Courant Number mean: 0.118804 max: 0.617047
smoothSolver: Solving for Ux, Initial residual = 0.000939005, Final residual = 1.68713e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00177357, Final residual = 5.07184e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00177321, Final residual = 9.32711e-05, No Iterations 5
time step continuity errors : sum local = 2.42219e-08, global = -2.14049e-09, cumulative = 4.28926e-06
GAMG: Solving for p, Initial residual = 0.000318135, Final residual = 7.73649e-07, No Iterations 15
time step continuity errors : sum local = 2.00953e-10, global = 7.00507e-12, cumulative = 4.28926e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000862295, Final residual = 9.99354e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00197932, Final residual = 3.07953e-06, No Iterations 4
ExecutionTime = 13.82 s ClockTime = 14 s
Time = 1.345
Courant Number mean: 0.118867 max: 0.617045
smoothSolver: Solving for Ux, Initial residual = 0.000938601, Final residual = 1.68686e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00177505, Final residual = 5.07973e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00174472, Final residual = 0.000170478, No Iterations 4
time step continuity errors : sum local = 4.42826e-08, global = 4.31118e-09, cumulative = 4.29357e-06
GAMG: Solving for p, Initial residual = 0.000348274, Final residual = 8.14631e-07, No Iterations 16
time step continuity errors : sum local = 2.11648e-10, global = 9.54212e-12, cumulative = 4.29358e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000862628, Final residual = 1.58741e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00197722, Final residual = 3.06763e-06, No Iterations 4
ExecutionTime = 13.84 s ClockTime = 14 s
Time = 1.3475
Courant Number mean: 0.11893 max: 0.617043
smoothSolver: Solving for Ux, Initial residual = 0.000938121, Final residual = 1.68582e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00177673, Final residual = 5.08576e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00177701, Final residual = 9.69389e-05, No Iterations 5
time step continuity errors : sum local = 2.51857e-08, global = -1.8934e-09, cumulative = 4.29169e-06
GAMG: Solving for p, Initial residual = 0.000321645, Final residual = 7.96884e-07, No Iterations 15
time step continuity errors : sum local = 2.07077e-10, global = 7.48589e-12, cumulative = 4.2917e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000862922, Final residual = 9.98999e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00197486, Final residual = 3.05173e-06, No Iterations 4
ExecutionTime = 13.87 s ClockTime = 14 s
Time = 1.35
Courant Number mean: 0.118993 max: 0.617041
smoothSolver: Solving for Ux, Initial residual = 0.000937677, Final residual = 1.68461e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00177852, Final residual = 5.09363e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00182474, Final residual = 0.00016729, No Iterations 4
time step continuity errors : sum local = 4.3476e-08, global = 4.24211e-09, cumulative = 4.29594e-06
GAMG: Solving for p, Initial residual = 0.000349022, Final residual = 8.04261e-07, No Iterations 16
time step continuity errors : sum local = 2.0907e-10, global = 9.51083e-12, cumulative = 4.29595e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000863463, Final residual = 1.58162e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00197263, Final residual = 3.04251e-06, No Iterations 4
ExecutionTime = 13.89 s ClockTime = 14 s
Time = 1.3525
Courant Number mean: 0.119055 max: 0.617039
smoothSolver: Solving for Ux, Initial residual = 0.000937212, Final residual = 1.68419e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00178037, Final residual = 5.09982e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00188981, Final residual = 0.000105903, No Iterations 5
time step continuity errors : sum local = 2.75288e-08, global = -1.68084e-09, cumulative = 4.29427e-06
GAMG: Solving for p, Initial residual = 0.00033804, Final residual = 8.17023e-07, No Iterations 15
time step continuity errors : sum local = 2.12416e-10, global = 7.73238e-12, cumulative = 4.29428e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00086374, Final residual = 9.99871e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00197028, Final residual = 3.02737e-06, No Iterations 4
ExecutionTime = 13.92 s ClockTime = 14 s
Time = 1.355
Courant Number mean: 0.119117 max: 0.617037
smoothSolver: Solving for Ux, Initial residual = 0.000936726, Final residual = 1.68269e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00178263, Final residual = 5.10837e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0018255, Final residual = 0.000175126, No Iterations 4
time step continuity errors : sum local = 4.55346e-08, global = 4.28649e-09, cumulative = 4.29856e-06
GAMG: Solving for p, Initial residual = 0.000360514, Final residual = 8.37104e-07, No Iterations 16
time step continuity errors : sum local = 2.17714e-10, global = 9.89857e-12, cumulative = 4.29857e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000864134, Final residual = 9.99801e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00196805, Final residual = 3.02251e-06, No Iterations 4
ExecutionTime = 13.94 s ClockTime = 14 s
Time = 1.3575
Courant Number mean: 0.119178 max: 0.617035
smoothSolver: Solving for Ux, Initial residual = 0.0009362, Final residual = 1.6817e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00178502, Final residual = 5.11782e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00178063, Final residual = 9.8812e-05, No Iterations 5
time step continuity errors : sum local = 2.57007e-08, global = -2.03268e-09, cumulative = 4.29654e-06
GAMG: Solving for p, Initial residual = 0.000323825, Final residual = 8.1099e-07, No Iterations 15
time step continuity errors : sum local = 2.10992e-10, global = 7.58451e-12, cumulative = 4.29655e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000864446, Final residual = 1.57662e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00196561, Final residual = 3.01535e-06, No Iterations 4
ExecutionTime = 13.97 s ClockTime = 14 s
Time = 1.36
Courant Number mean: 0.119239 max: 0.617034
smoothSolver: Solving for Ux, Initial residual = 0.000935751, Final residual = 1.68055e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00178721, Final residual = 5.12745e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00181731, Final residual = 0.000176511, No Iterations 4
time step continuity errors : sum local = 4.59271e-08, global = 4.17819e-09, cumulative = 4.30072e-06
GAMG: Solving for p, Initial residual = 0.000355981, Final residual = 8.20577e-07, No Iterations 16
time step continuity errors : sum local = 2.13569e-10, global = 9.79492e-12, cumulative = 4.30073e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000864627, Final residual = 1.57594e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00196319, Final residual = 9.98733e-06, No Iterations 3
ExecutionTime = 14 s ClockTime = 14 s
Time = 1.3625
Courant Number mean: 0.119299 max: 0.617032
smoothSolver: Solving for Ux, Initial residual = 0.000935276, Final residual = 1.67976e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00178923, Final residual = 5.13494e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00189744, Final residual = 0.00018501, No Iterations 4
time step continuity errors : sum local = 4.81558e-08, global = 1.27374e-09, cumulative = 4.30201e-06
GAMG: Solving for p, Initial residual = 0.000366441, Final residual = 9.52343e-07, No Iterations 14
time step continuity errors : sum local = 2.47951e-10, global = 8.25953e-12, cumulative = 4.30202e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000864813, Final residual = 1.58043e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00196083, Final residual = 9.96555e-06, No Iterations 3
ExecutionTime = 14.03 s ClockTime = 14 s
Time = 1.365
Courant Number mean: 0.119359 max: 0.61703
smoothSolver: Solving for Ux, Initial residual = 0.000934833, Final residual = 1.67644e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00179096, Final residual = 5.14386e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00186637, Final residual = 9.86166e-05, No Iterations 5
time step continuity errors : sum local = 2.56755e-08, global = -2.27242e-09, cumulative = 4.29974e-06
GAMG: Solving for p, Initial residual = 0.000327064, Final residual = 8.25358e-07, No Iterations 15
time step continuity errors : sum local = 2.14938e-10, global = 7.71875e-12, cumulative = 4.29975e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000865059, Final residual = 1.57897e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00195859, Final residual = 9.9333e-06, No Iterations 3
ExecutionTime = 14.06 s ClockTime = 14 s
Time = 1.3675
Courant Number mean: 0.119418 max: 0.617028
smoothSolver: Solving for Ux, Initial residual = 0.000934403, Final residual = 1.67879e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00179277, Final residual = 5.15451e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00185019, Final residual = 0.000178496, No Iterations 4
time step continuity errors : sum local = 4.64876e-08, global = 4.0416e-09, cumulative = 4.30379e-06
GAMG: Solving for p, Initial residual = 0.000359698, Final residual = 7.57775e-07, No Iterations 16
time step continuity errors : sum local = 1.97404e-10, global = 8.40655e-12, cumulative = 4.3038e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000865419, Final residual = 1.57718e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00195641, Final residual = 9.91183e-06, No Iterations 3
ExecutionTime = 14.08 s ClockTime = 14 s
Time = 1.37
Courant Number mean: 0.119477 max: 0.617026
smoothSolver: Solving for Ux, Initial residual = 0.000933887, Final residual = 1.67498e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00179439, Final residual = 5.16267e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00193062, Final residual = 0.000185048, No Iterations 4
time step continuity errors : sum local = 4.82076e-08, global = 1.41468e-09, cumulative = 4.30522e-06
GAMG: Solving for p, Initial residual = 0.000368989, Final residual = 4.59396e-07, No Iterations 16
time step continuity errors : sum local = 1.19704e-10, global = 4.30603e-12, cumulative = 4.30522e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000865771, Final residual = 1.57617e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00195425, Final residual = 9.88936e-06, No Iterations 3
ExecutionTime = 14.11 s ClockTime = 14 s
Time = 1.3725
Courant Number mean: 0.119535 max: 0.617024
smoothSolver: Solving for Ux, Initial residual = 0.000933416, Final residual = 1.67388e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00179591, Final residual = 5.17541e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00182857, Final residual = 9.99075e-05, No Iterations 5
time step continuity errors : sum local = 2.60352e-08, global = -2.22341e-09, cumulative = 4.303e-06
GAMG: Solving for p, Initial residual = 0.00032458, Final residual = 8.28815e-07, No Iterations 15
time step continuity errors : sum local = 2.16028e-10, global = 7.77568e-12, cumulative = 4.30301e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000866122, Final residual = 1.5697e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00195219, Final residual = 9.85784e-06, No Iterations 3
ExecutionTime = 14.13 s ClockTime = 14 s
Time = 1.375
Courant Number mean: 0.119593 max: 0.617022
smoothSolver: Solving for Ux, Initial residual = 0.000933014, Final residual = 1.67454e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00179765, Final residual = 5.18675e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00182014, Final residual = 0.000178846, No Iterations 4
time step continuity errors : sum local = 4.66177e-08, global = 4.03566e-09, cumulative = 4.30704e-06
GAMG: Solving for p, Initial residual = 0.000355739, Final residual = 7.80051e-07, No Iterations 16
time step continuity errors : sum local = 2.03371e-10, global = 8.90396e-12, cumulative = 4.30705e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000866461, Final residual = 1.56439e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00195009, Final residual = 9.8305e-06, No Iterations 3
ExecutionTime = 14.15 s ClockTime = 14 s
Time = 1.3775
Courant Number mean: 0.119651 max: 0.61702
smoothSolver: Solving for Ux, Initial residual = 0.00093251, Final residual = 1.67187e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00179953, Final residual = 5.19465e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00181646, Final residual = 0.000104406, No Iterations 5
time step continuity errors : sum local = 2.72201e-08, global = -1.67228e-09, cumulative = 4.30538e-06
GAMG: Solving for p, Initial residual = 0.000328033, Final residual = 8.29953e-07, No Iterations 15
time step continuity errors : sum local = 2.16423e-10, global = 8.11379e-12, cumulative = 4.30539e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000866769, Final residual = 1.56418e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00194798, Final residual = 9.81704e-06, No Iterations 3
ExecutionTime = 14.18 s ClockTime = 14 s
Time = 1.38
Courant Number mean: 0.119709 max: 0.617018
smoothSolver: Solving for Ux, Initial residual = 0.000932039, Final residual = 1.67161e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00180145, Final residual = 5.2058e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00181446, Final residual = 0.000105115, No Iterations 5
time step continuity errors : sum local = 2.74115e-08, global = -2.80737e-09, cumulative = 4.30258e-06
GAMG: Solving for p, Initial residual = 0.000324439, Final residual = 9.02155e-07, No Iterations 15
time step continuity errors : sum local = 2.35304e-10, global = 8.56643e-12, cumulative = 4.30259e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000867023, Final residual = 1.56043e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00194562, Final residual = 9.81022e-06, No Iterations 3
ExecutionTime = 14.2 s ClockTime = 14 s
Time = 1.3825
Courant Number mean: 0.11977 max: 0.617016
smoothSolver: Solving for Ux, Initial residual = 0.000931557, Final residual = 1.67097e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00180324, Final residual = 5.21518e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00180561, Final residual = 0.000178917, No Iterations 4
time step continuity errors : sum local = 4.66679e-08, global = 4.10918e-09, cumulative = 4.3067e-06
GAMG: Solving for p, Initial residual = 0.000353397, Final residual = 7.94398e-07, No Iterations 16
time step continuity errors : sum local = 2.0725e-10, global = 9.3329e-12, cumulative = 4.30671e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000867271, Final residual = 1.55789e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00194322, Final residual = 9.79551e-06, No Iterations 3
ExecutionTime = 14.22 s ClockTime = 14 s
Time = 1.385
Courant Number mean: 0.11983 max: 0.617015
smoothSolver: Solving for Ux, Initial residual = 0.000931114, Final residual = 1.66814e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00180474, Final residual = 5.22249e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00181788, Final residual = 0.00010482, No Iterations 5
time step continuity errors : sum local = 2.73453e-08, global = -1.6017e-09, cumulative = 4.3051e-06
GAMG: Solving for p, Initial residual = 0.000327525, Final residual = 8.30255e-07, No Iterations 15
time step continuity errors : sum local = 2.16633e-10, global = 8.15968e-12, cumulative = 4.30511e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00086748, Final residual = 1.56088e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00194081, Final residual = 9.76633e-06, No Iterations 3
ExecutionTime = 14.25 s ClockTime = 14 s
Time = 1.3875
Courant Number mean: 0.119891 max: 0.617013
smoothSolver: Solving for Ux, Initial residual = 0.00093075, Final residual = 1.66857e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00180614, Final residual = 5.23473e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00183583, Final residual = 0.000182283, No Iterations 4
time step continuity errors : sum local = 4.7563e-08, global = 3.8702e-09, cumulative = 4.30898e-06
GAMG: Solving for p, Initial residual = 0.000356421, Final residual = 7.39417e-07, No Iterations 16
time step continuity errors : sum local = 1.92979e-10, global = 8.38661e-12, cumulative = 4.30899e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000867735, Final residual = 1.56265e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00193844, Final residual = 9.73664e-06, No Iterations 3
ExecutionTime = 14.27 s ClockTime = 14 s
Time = 1.39
Courant Number mean: 0.119953 max: 0.617011
smoothSolver: Solving for Ux, Initial residual = 0.000930317, Final residual = 1.66635e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00180793, Final residual = 5.24236e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00193995, Final residual = 0.000189173, No Iterations 4
time step continuity errors : sum local = 4.9373e-08, global = 1.2544e-09, cumulative = 4.31024e-06
GAMG: Solving for p, Initial residual = 0.000362587, Final residual = 9.56149e-07, No Iterations 14
time step continuity errors : sum local = 2.49629e-10, global = 8.23601e-12, cumulative = 4.31025e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000867946, Final residual = 1.55831e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00193606, Final residual = 9.71623e-06, No Iterations 3
ExecutionTime = 14.29 s ClockTime = 14 s
Time = 1.3925
Courant Number mean: 0.120014 max: 0.617009
smoothSolver: Solving for Ux, Initial residual = 0.000929893, Final residual = 1.66554e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00181004, Final residual = 5.253e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00195494, Final residual = 0.000184661, No Iterations 4
time step continuity errors : sum local = 4.82101e-08, global = 2.30752e-09, cumulative = 4.31256e-06
GAMG: Solving for p, Initial residual = 0.000364253, Final residual = 5.39738e-07, No Iterations 16
time step continuity errors : sum local = 1.40947e-10, global = 5.2171e-12, cumulative = 4.31257e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000868112, Final residual = 1.56061e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00193386, Final residual = 9.69864e-06, No Iterations 3
ExecutionTime = 14.31 s ClockTime = 14 s
Time = 1.395
Courant Number mean: 0.120076 max: 0.617007
smoothSolver: Solving for Ux, Initial residual = 0.000929392, Final residual = 1.66497e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00181268, Final residual = 5.26245e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00191147, Final residual = 0.000187691, No Iterations 4
time step continuity errors : sum local = 4.90124e-08, global = 1.91321e-09, cumulative = 4.31448e-06
GAMG: Solving for p, Initial residual = 0.000371986, Final residual = 5.01876e-07, No Iterations 16
time step continuity errors : sum local = 1.31089e-10, global = 4.69124e-12, cumulative = 4.31448e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00086828, Final residual = 1.56281e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00193183, Final residual = 9.67512e-06, No Iterations 3
ExecutionTime = 14.33 s ClockTime = 14 s
Time = 1.3975
Courant Number mean: 0.120137 max: 0.617005
smoothSolver: Solving for Ux, Initial residual = 0.000928826, Final residual = 1.66406e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00181553, Final residual = 5.27266e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00187994, Final residual = 0.000187328, No Iterations 4
time step continuity errors : sum local = 4.89301e-08, global = 1.98897e-09, cumulative = 4.31647e-06
GAMG: Solving for p, Initial residual = 0.000360677, Final residual = 4.91839e-07, No Iterations 16
time step continuity errors : sum local = 1.28502e-10, global = 4.69245e-12, cumulative = 4.31648e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000868495, Final residual = 1.56182e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00192981, Final residual = 9.6769e-06, No Iterations 3
ExecutionTime = 14.35 s ClockTime = 14 s
Time = 1.4
Courant Number mean: 0.120199 max: 0.617004
smoothSolver: Solving for Ux, Initial residual = 0.000928283, Final residual = 1.66305e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00181808, Final residual = 5.28174e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00202972, Final residual = 0.00018726, No Iterations 4
time step continuity errors : sum local = 4.89113e-08, global = 1.98158e-09, cumulative = 4.31846e-06
GAMG: Solving for p, Initial residual = 0.000360909, Final residual = 4.96111e-07, No Iterations 16
time step continuity errors : sum local = 1.2958e-10, global = 4.68349e-12, cumulative = 4.31846e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000868774, Final residual = 1.55867e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00192781, Final residual = 9.66808e-06, No Iterations 3
ExecutionTime = 14.4 s ClockTime = 15 s
Time = 1.4025
Courant Number mean: 0.12026 max: 0.617002
smoothSolver: Solving for Ux, Initial residual = 0.000927815, Final residual = 1.66301e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00182036, Final residual = 5.2911e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00194047, Final residual = 0.000186172, No Iterations 4
time step continuity errors : sum local = 4.86175e-08, global = 1.99283e-09, cumulative = 4.32046e-06
GAMG: Solving for p, Initial residual = 0.000363658, Final residual = 4.90436e-07, No Iterations 16
time step continuity errors : sum local = 1.28085e-10, global = 4.55043e-12, cumulative = 4.32046e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000869106, Final residual = 1.55777e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00192586, Final residual = 9.63684e-06, No Iterations 3
ExecutionTime = 14.42 s ClockTime = 15 s
Time = 1.405
Courant Number mean: 0.120321 max: 0.617
smoothSolver: Solving for Ux, Initial residual = 0.000927336, Final residual = 1.66205e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00182281, Final residual = 5.30094e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00191829, Final residual = 0.000185497, No Iterations 4
time step continuity errors : sum local = 4.84405e-08, global = 1.96868e-09, cumulative = 4.32243e-06
GAMG: Solving for p, Initial residual = 0.000362688, Final residual = 4.83806e-07, No Iterations 16
time step continuity errors : sum local = 1.26361e-10, global = 4.55688e-12, cumulative = 4.32243e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000869518, Final residual = 1.55661e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00192401, Final residual = 9.6128e-06, No Iterations 3
ExecutionTime = 14.45 s ClockTime = 15 s
Time = 1.4075
Courant Number mean: 0.120381 max: 0.616998
smoothSolver: Solving for Ux, Initial residual = 0.000926875, Final residual = 1.66162e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00182492, Final residual = 5.30932e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00187948, Final residual = 0.000185898, No Iterations 4
time step continuity errors : sum local = 4.85508e-08, global = 1.95821e-09, cumulative = 4.32439e-06
GAMG: Solving for p, Initial residual = 0.000361227, Final residual = 4.79381e-07, No Iterations 16
time step continuity errors : sum local = 1.25229e-10, global = 4.48803e-12, cumulative = 4.3244e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000869903, Final residual = 1.5667e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00192213, Final residual = 9.61657e-06, No Iterations 3
ExecutionTime = 14.47 s ClockTime = 15 s
Time = 1.41
Courant Number mean: 0.120441 max: 0.616996
smoothSolver: Solving for Ux, Initial residual = 0.000926377, Final residual = 1.66097e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00182684, Final residual = 5.31729e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00183902, Final residual = 0.000100511, No Iterations 5
time step continuity errors : sum local = 2.62569e-08, global = -2.15252e-09, cumulative = 4.32224e-06
GAMG: Solving for p, Initial residual = 0.000329044, Final residual = 8.36431e-07, No Iterations 15
time step continuity errors : sum local = 2.18553e-10, global = 8.01543e-12, cumulative = 4.32225e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000870269, Final residual = 1.56292e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00192041, Final residual = 9.60077e-06, No Iterations 3
ExecutionTime = 14.49 s ClockTime = 15 s
Time = 1.4125
Courant Number mean: 0.1205 max: 0.616995
smoothSolver: Solving for Ux, Initial residual = 0.000925946, Final residual = 1.6622e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00182849, Final residual = 5.32761e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00187223, Final residual = 0.000179944, No Iterations 4
time step continuity errors : sum local = 4.70202e-08, global = 3.93383e-09, cumulative = 4.32619e-06
GAMG: Solving for p, Initial residual = 0.000357722, Final residual = 7.03507e-07, No Iterations 16
time step continuity errors : sum local = 1.83874e-10, global = 7.60494e-12, cumulative = 4.32619e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000870631, Final residual = 1.56782e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00191866, Final residual = 9.58511e-06, No Iterations 3
ExecutionTime = 14.51 s ClockTime = 15 s
Time = 1.415
Courant Number mean: 0.120559 max: 0.616993
smoothSolver: Solving for Ux, Initial residual = 0.000925434, Final residual = 1.65982e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00182999, Final residual = 5.33347e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00201712, Final residual = 0.000187398, No Iterations 4
time step continuity errors : sum local = 4.89801e-08, global = 1.09811e-09, cumulative = 4.32729e-06
GAMG: Solving for p, Initial residual = 0.00037285, Final residual = 8.69697e-07, No Iterations 14
time step continuity errors : sum local = 2.27375e-10, global = 7.37174e-12, cumulative = 4.3273e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000870884, Final residual = 1.56361e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00191675, Final residual = 9.56318e-06, No Iterations 3
ExecutionTime = 14.53 s ClockTime = 15 s
Time = 1.4175
Courant Number mean: 0.120618 max: 0.616991
smoothSolver: Solving for Ux, Initial residual = 0.00092495, Final residual = 1.65922e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00183149, Final residual = 5.34287e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00200707, Final residual = 0.000179539, No Iterations 4
time step continuity errors : sum local = 4.69398e-08, global = 2.46076e-09, cumulative = 4.32976e-06
GAMG: Solving for p, Initial residual = 0.000373199, Final residual = 5.20466e-07, No Iterations 16
time step continuity errors : sum local = 1.36113e-10, global = 5.04202e-12, cumulative = 4.32977e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000871165, Final residual = 1.56502e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00191478, Final residual = 9.5419e-06, No Iterations 3
ExecutionTime = 14.55 s ClockTime = 15 s
Time = 1.42
Courant Number mean: 0.120677 max: 0.616989
smoothSolver: Solving for Ux, Initial residual = 0.000924466, Final residual = 1.65825e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0018322, Final residual = 5.3504e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00191283, Final residual = 0.000184701, No Iterations 4
time step continuity errors : sum local = 4.83023e-08, global = 1.77702e-09, cumulative = 4.33154e-06
GAMG: Solving for p, Initial residual = 0.00036546, Final residual = 4.5792e-07, No Iterations 16
time step continuity errors : sum local = 1.19786e-10, global = 4.23744e-12, cumulative = 4.33155e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000871557, Final residual = 1.5631e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0019128, Final residual = 9.54649e-06, No Iterations 3
ExecutionTime = 14.58 s ClockTime = 15 s
Time = 1.4225
Courant Number mean: 0.120735 max: 0.616988
smoothSolver: Solving for Ux, Initial residual = 0.000923965, Final residual = 1.65785e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00183311, Final residual = 5.35942e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00195565, Final residual = 0.000184355, No Iterations 4
time step continuity errors : sum local = 4.823e-08, global = 2.01902e-09, cumulative = 4.33357e-06
GAMG: Solving for p, Initial residual = 0.000367059, Final residual = 4.61743e-07, No Iterations 16
time step continuity errors : sum local = 1.20838e-10, global = 4.3038e-12, cumulative = 4.33357e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000872066, Final residual = 1.56274e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0019109, Final residual = 9.54199e-06, No Iterations 3
ExecutionTime = 14.6 s ClockTime = 15 s
Time = 1.425
Courant Number mean: 0.120792 max: 0.616986
smoothSolver: Solving for Ux, Initial residual = 0.000923482, Final residual = 1.65652e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0018338, Final residual = 5.36806e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00202662, Final residual = 0.000185371, No Iterations 4
time step continuity errors : sum local = 4.85085e-08, global = 1.98545e-09, cumulative = 4.33556e-06
GAMG: Solving for p, Initial residual = 0.000370785, Final residual = 4.74666e-07, No Iterations 16
time step continuity errors : sum local = 1.24239e-10, global = 4.41405e-12, cumulative = 4.33556e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000872517, Final residual = 1.56065e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00190902, Final residual = 9.53171e-06, No Iterations 3
ExecutionTime = 14.62 s ClockTime = 15 s
Time = 1.4275
Courant Number mean: 0.120849 max: 0.616984
smoothSolver: Solving for Ux, Initial residual = 0.000923055, Final residual = 1.65622e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00183492, Final residual = 5.38036e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00198066, Final residual = 0.000184818, No Iterations 4
time step continuity errors : sum local = 4.83798e-08, global = 1.92031e-09, cumulative = 4.33748e-06
GAMG: Solving for p, Initial residual = 0.000367297, Final residual = 4.61908e-07, No Iterations 16
time step continuity errors : sum local = 1.20949e-10, global = 4.41797e-12, cumulative = 4.33748e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000872927, Final residual = 1.56281e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00190719, Final residual = 9.51235e-06, No Iterations 3
ExecutionTime = 14.64 s ClockTime = 15 s
Time = 1.43
Courant Number mean: 0.120906 max: 0.616982
smoothSolver: Solving for Ux, Initial residual = 0.000922608, Final residual = 1.65484e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00183593, Final residual = 5.39221e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00188513, Final residual = 0.000186041, No Iterations 4
time step continuity errors : sum local = 4.8716e-08, global = 2.00126e-09, cumulative = 4.33949e-06
GAMG: Solving for p, Initial residual = 0.000363816, Final residual = 4.84876e-07, No Iterations 16
time step continuity errors : sum local = 1.27001e-10, global = 4.59759e-12, cumulative = 4.33949e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000873364, Final residual = 1.56715e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00190542, Final residual = 9.49739e-06, No Iterations 3
ExecutionTime = 14.66 s ClockTime = 15 s
Time = 1.4325
Courant Number mean: 0.120962 max: 0.61698
smoothSolver: Solving for Ux, Initial residual = 0.00092212, Final residual = 1.65506e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0018375, Final residual = 5.40354e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00187709, Final residual = 0.000185692, No Iterations 4
time step continuity errors : sum local = 4.86354e-08, global = 1.89815e-09, cumulative = 4.34139e-06
GAMG: Solving for p, Initial residual = 0.000364046, Final residual = 4.66193e-07, No Iterations 16
time step continuity errors : sum local = 1.22131e-10, global = 4.48757e-12, cumulative = 4.34139e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000873874, Final residual = 1.57207e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00190367, Final residual = 9.47834e-06, No Iterations 3
ExecutionTime = 14.69 s ClockTime = 15 s
Time = 1.435
Courant Number mean: 0.121017 max: 0.616979
smoothSolver: Solving for Ux, Initial residual = 0.000921622, Final residual = 1.65343e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00183968, Final residual = 5.41524e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00185428, Final residual = 9.9114e-05, No Iterations 5
time step continuity errors : sum local = 2.59645e-08, global = -2.12153e-09, cumulative = 4.33927e-06
GAMG: Solving for p, Initial residual = 0.000329464, Final residual = 8.3529e-07, No Iterations 15
time step continuity errors : sum local = 2.18863e-10, global = 8.17464e-12, cumulative = 4.33928e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000874509, Final residual = 1.56879e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00190197, Final residual = 9.46261e-06, No Iterations 3
ExecutionTime = 14.71 s ClockTime = 15 s
Time = 1.4375
Courant Number mean: 0.121072 max: 0.616977
smoothSolver: Solving for Ux, Initial residual = 0.000921131, Final residual = 1.65516e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00184215, Final residual = 5.42854e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0019416, Final residual = 0.000178534, No Iterations 4
time step continuity errors : sum local = 4.67772e-08, global = 3.92834e-09, cumulative = 4.34321e-06
GAMG: Solving for p, Initial residual = 0.000360279, Final residual = 6.7846e-07, No Iterations 16
time step continuity errors : sum local = 1.77786e-10, global = 7.33596e-12, cumulative = 4.34322e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000875226, Final residual = 1.57672e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00190024, Final residual = 9.45132e-06, No Iterations 3
ExecutionTime = 14.73 s ClockTime = 15 s
Time = 1.44
Courant Number mean: 0.121127 max: 0.616975
smoothSolver: Solving for Ux, Initial residual = 0.000920594, Final residual = 1.65261e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00184452, Final residual = 5.43882e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00198129, Final residual = 0.000190759, No Iterations 4
time step continuity errors : sum local = 4.99861e-08, global = 1.11962e-09, cumulative = 4.34433e-06
GAMG: Solving for p, Initial residual = 0.000372881, Final residual = 8.83454e-07, No Iterations 14
time step continuity errors : sum local = 2.31557e-10, global = 7.83245e-12, cumulative = 4.34434e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000875956, Final residual = 1.57424e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00189856, Final residual = 9.44912e-06, No Iterations 3
ExecutionTime = 14.76 s ClockTime = 15 s
Time = 1.4425
Courant Number mean: 0.121181 max: 0.616973
smoothSolver: Solving for Ux, Initial residual = 0.000920147, Final residual = 1.65213e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00184697, Final residual = 5.45241e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00192166, Final residual = 0.000181597, No Iterations 4
time step continuity errors : sum local = 4.75925e-08, global = 2.42928e-09, cumulative = 4.34677e-06
GAMG: Solving for p, Initial residual = 0.000364332, Final residual = 5.24418e-07, No Iterations 16
time step continuity errors : sum local = 1.37459e-10, global = 5.09553e-12, cumulative = 4.34678e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000876666, Final residual = 1.57643e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00189688, Final residual = 9.44894e-06, No Iterations 3
ExecutionTime = 14.77 s ClockTime = 15 s
Time = 1.445
Courant Number mean: 0.121235 max: 0.616972
smoothSolver: Solving for Ux, Initial residual = 0.000919698, Final residual = 1.6513e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00184966, Final residual = 5.46567e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00186126, Final residual = 0.000184525, No Iterations 4
time step continuity errors : sum local = 4.83644e-08, global = 1.77407e-09, cumulative = 4.34855e-06
GAMG: Solving for p, Initial residual = 0.000364706, Final residual = 4.63158e-07, No Iterations 16
time step continuity errors : sum local = 1.2142e-10, global = 4.55084e-12, cumulative = 4.34856e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000877339, Final residual = 1.57568e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00189521, Final residual = 9.44815e-06, No Iterations 3
ExecutionTime = 14.8 s ClockTime = 15 s
Time = 1.4475
Courant Number mean: 0.121289 max: 0.61697
smoothSolver: Solving for Ux, Initial residual = 0.000919256, Final residual = 1.6507e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00185212, Final residual = 5.47834e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00190827, Final residual = 0.000184744, No Iterations 4
time step continuity errors : sum local = 4.84312e-08, global = 2.07553e-09, cumulative = 4.35063e-06
GAMG: Solving for p, Initial residual = 0.000366532, Final residual = 4.98939e-07, No Iterations 16
time step continuity errors : sum local = 1.30833e-10, global = 4.87144e-12, cumulative = 4.35064e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000877961, Final residual = 1.57422e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00189353, Final residual = 9.42741e-06, No Iterations 3
ExecutionTime = 14.82 s ClockTime = 15 s
Time = 1.45
Courant Number mean: 0.121345 max: 0.616968
smoothSolver: Solving for Ux, Initial residual = 0.000918798, Final residual = 1.65115e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0018547, Final residual = 5.49114e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00188602, Final residual = 0.000184671, No Iterations 4
time step continuity errors : sum local = 4.84209e-08, global = 1.94147e-09, cumulative = 4.35258e-06
GAMG: Solving for p, Initial residual = 0.000367816, Final residual = 4.86433e-07, No Iterations 16
time step continuity errors : sum local = 1.27567e-10, global = 4.69639e-12, cumulative = 4.35258e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000878508, Final residual = 1.57353e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00189192, Final residual = 9.42672e-06, No Iterations 3
ExecutionTime = 14.85 s ClockTime = 15 s
Time = 1.4525
Courant Number mean: 0.121402 max: 0.616967
smoothSolver: Solving for Ux, Initial residual = 0.000918295, Final residual = 1.65024e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00185727, Final residual = 5.50418e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0018882, Final residual = 0.00018372, No Iterations 4
time step continuity errors : sum local = 4.81788e-08, global = 2.00444e-09, cumulative = 4.35459e-06
GAMG: Solving for p, Initial residual = 0.00036334, Final residual = 4.86698e-07, No Iterations 16
time step continuity errors : sum local = 1.27659e-10, global = 4.76824e-12, cumulative = 4.35459e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000879018, Final residual = 1.58042e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00189026, Final residual = 9.4205e-06, No Iterations 3
ExecutionTime = 14.87 s ClockTime = 15 s
Time = 1.455
Courant Number mean: 0.121459 max: 0.616965
smoothSolver: Solving for Ux, Initial residual = 0.000917824, Final residual = 1.65006e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00185943, Final residual = 5.51585e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0018824, Final residual = 0.000183776, No Iterations 4
time step continuity errors : sum local = 4.82027e-08, global = 2.05838e-09, cumulative = 4.35665e-06
GAMG: Solving for p, Initial residual = 0.000366436, Final residual = 5.03484e-07, No Iterations 16
time step continuity errors : sum local = 1.3209e-10, global = 4.96125e-12, cumulative = 4.35665e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000879566, Final residual = 1.58307e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0018885, Final residual = 9.4031e-06, No Iterations 3
ExecutionTime = 14.91 s ClockTime = 15 s
Time = 1.4575
Courant Number mean: 0.121516 max: 0.616963
smoothSolver: Solving for Ux, Initial residual = 0.000917349, Final residual = 1.64979e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00186138, Final residual = 5.52798e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00191838, Final residual = 0.00018308, No Iterations 4
time step continuity errors : sum local = 4.80301e-08, global = 2.00684e-09, cumulative = 4.35866e-06
GAMG: Solving for p, Initial residual = 0.000364887, Final residual = 4.91252e-07, No Iterations 16
time step continuity errors : sum local = 1.2891e-10, global = 4.87185e-12, cumulative = 4.35867e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000880073, Final residual = 1.58711e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00188678, Final residual = 9.38782e-06, No Iterations 3
ExecutionTime = 14.93 s ClockTime = 15 s
Time = 1.46
Courant Number mean: 0.121573 max: 0.616961
smoothSolver: Solving for Ux, Initial residual = 0.000916895, Final residual = 1.64919e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00186301, Final residual = 5.53967e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00192215, Final residual = 0.000183688, No Iterations 4
time step continuity errors : sum local = 4.8199e-08, global = 2.0403e-09, cumulative = 4.36071e-06
GAMG: Solving for p, Initial residual = 0.000366916, Final residual = 4.9764e-07, No Iterations 16
time step continuity errors : sum local = 1.30608e-10, global = 4.92924e-12, cumulative = 4.36071e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000880603, Final residual = 1.58661e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00188515, Final residual = 9.37446e-06, No Iterations 3
ExecutionTime = 14.96 s ClockTime = 15 s
Time = 1.4625
Courant Number mean: 0.12163 max: 0.61696
smoothSolver: Solving for Ux, Initial residual = 0.000916455, Final residual = 1.64909e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00186437, Final residual = 5.5511e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00189412, Final residual = 0.000183437, No Iterations 4
time step continuity errors : sum local = 4.81423e-08, global = 1.98382e-09, cumulative = 4.3627e-06
GAMG: Solving for p, Initial residual = 0.000366158, Final residual = 4.88976e-07, No Iterations 16
time step continuity errors : sum local = 1.28359e-10, global = 4.87386e-12, cumulative = 4.3627e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000881076, Final residual = 1.58961e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00188355, Final residual = 9.36268e-06, No Iterations 3
ExecutionTime = 14.99 s ClockTime = 15 s
Time = 1.465
Courant Number mean: 0.121687 max: 0.616958
smoothSolver: Solving for Ux, Initial residual = 0.000915947, Final residual = 1.64866e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00186599, Final residual = 5.56256e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00196222, Final residual = 0.000183348, No Iterations 4
time step continuity errors : sum local = 4.813e-08, global = 2.02757e-09, cumulative = 4.36473e-06
GAMG: Solving for p, Initial residual = 0.000369047, Final residual = 4.94533e-07, No Iterations 16
time step continuity errors : sum local = 1.29853e-10, global = 4.9282e-12, cumulative = 4.36473e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000881497, Final residual = 1.58794e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00188197, Final residual = 9.38215e-06, No Iterations 3
ExecutionTime = 15.02 s ClockTime = 15 s
Time = 1.4675
Courant Number mean: 0.121744 max: 0.616956
smoothSolver: Solving for Ux, Initial residual = 0.000915413, Final residual = 1.64865e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00186754, Final residual = 5.57377e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00212925, Final residual = 0.000188386, No Iterations 4
time step continuity errors : sum local = 4.94629e-08, global = 1.84116e-09, cumulative = 4.36657e-06
GAMG: Solving for p, Initial residual = 0.000375574, Final residual = 4.75351e-07, No Iterations 16
time step continuity errors : sum local = 1.24834e-10, global = 4.78405e-12, cumulative = 4.36658e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000881947, Final residual = 1.58592e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00188046, Final residual = 9.37019e-06, No Iterations 3
ExecutionTime = 15.04 s ClockTime = 15 s
Time = 1.47
Courant Number mean: 0.121801 max: 0.616955
smoothSolver: Solving for Ux, Initial residual = 0.000914929, Final residual = 1.64806e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00186857, Final residual = 5.58383e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00218401, Final residual = 0.000174964, No Iterations 4
time step continuity errors : sum local = 4.59392e-08, global = 2.43836e-09, cumulative = 4.36902e-06
GAMG: Solving for p, Initial residual = 0.000379477, Final residual = 5.6965e-07, No Iterations 16
time step continuity errors : sum local = 1.49578e-10, global = 5.76565e-12, cumulative = 4.36902e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000882446, Final residual = 1.58611e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00187889, Final residual = 9.36554e-06, No Iterations 3
ExecutionTime = 15.07 s ClockTime = 15 s
Time = 1.4725
Courant Number mean: 0.121858 max: 0.616953
smoothSolver: Solving for Ux, Initial residual = 0.000914409, Final residual = 1.64868e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00187007, Final residual = 5.5961e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00203044, Final residual = 0.00018343, No Iterations 4
time step continuity errors : sum local = 4.81648e-08, global = 1.79501e-09, cumulative = 4.37082e-06
GAMG: Solving for p, Initial residual = 0.000376413, Final residual = 4.81519e-07, No Iterations 16
time step continuity errors : sum local = 1.26465e-10, global = 4.8555e-12, cumulative = 4.37082e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000882928, Final residual = 1.58606e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00187729, Final residual = 9.34932e-06, No Iterations 3
ExecutionTime = 15.09 s ClockTime = 15 s
Time = 1.475
Courant Number mean: 0.121914 max: 0.616951
smoothSolver: Solving for Ux, Initial residual = 0.00091395, Final residual = 1.64697e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00187139, Final residual = 5.60767e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00212442, Final residual = 0.000183205, No Iterations 4
time step continuity errors : sum local = 4.81141e-08, global = 2.0763e-09, cumulative = 4.3729e-06
GAMG: Solving for p, Initial residual = 0.000382386, Final residual = 5.03225e-07, No Iterations 16
time step continuity errors : sum local = 1.32189e-10, global = 5.18494e-12, cumulative = 4.3729e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000883384, Final residual = 1.59624e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00187564, Final residual = 9.33821e-06, No Iterations 3
ExecutionTime = 15.11 s ClockTime = 15 s
Time = 1.4775
Courant Number mean: 0.12197 max: 0.61695
smoothSolver: Solving for Ux, Initial residual = 0.000913496, Final residual = 1.64729e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0018722, Final residual = 5.61833e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00199689, Final residual = 0.000181417, No Iterations 4
time step continuity errors : sum local = 4.7654e-08, global = 1.99503e-09, cumulative = 4.3749e-06
GAMG: Solving for p, Initial residual = 0.000373196, Final residual = 4.99421e-07, No Iterations 16
time step continuity errors : sum local = 1.3122e-10, global = 5.07521e-12, cumulative = 4.3749e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000883822, Final residual = 1.60293e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.001874, Final residual = 9.32423e-06, No Iterations 3
ExecutionTime = 15.14 s ClockTime = 15 s
Time = 1.48
Courant Number mean: 0.122026 max: 0.616948
smoothSolver: Solving for Ux, Initial residual = 0.000913009, Final residual = 1.64711e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00187342, Final residual = 5.63057e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00205525, Final residual = 0.000179453, No Iterations 4
time step continuity errors : sum local = 4.71504e-08, global = 2.07803e-09, cumulative = 4.37698e-06
GAMG: Solving for p, Initial residual = 0.000375696, Final residual = 5.09611e-07, No Iterations 16
time step continuity errors : sum local = 1.33924e-10, global = 5.18466e-12, cumulative = 4.37699e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000884271, Final residual = 1.6047e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00187235, Final residual = 9.31296e-06, No Iterations 3
ExecutionTime = 15.16 s ClockTime = 15 s
Time = 1.4825
Courant Number mean: 0.122081 max: 0.616947
smoothSolver: Solving for Ux, Initial residual = 0.000912525, Final residual = 1.64681e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00187473, Final residual = 5.64448e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00201654, Final residual = 0.000182204, No Iterations 4
time step continuity errors : sum local = 4.7886e-08, global = 1.89104e-09, cumulative = 4.37888e-06
GAMG: Solving for p, Initial residual = 0.000375152, Final residual = 4.76274e-07, No Iterations 16
time step continuity errors : sum local = 1.25201e-10, global = 4.81365e-12, cumulative = 4.37888e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000884726, Final residual = 1.6044e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00187066, Final residual = 9.31418e-06, No Iterations 3
ExecutionTime = 15.19 s ClockTime = 15 s
Time = 1.485
Courant Number mean: 0.122136 max: 0.616945
smoothSolver: Solving for Ux, Initial residual = 0.000912105, Final residual = 1.64645e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00187597, Final residual = 5.6567e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00195744, Final residual = 0.000180712, No Iterations 4
time step continuity errors : sum local = 4.75034e-08, global = 2.04537e-09, cumulative = 4.38093e-06
GAMG: Solving for p, Initial residual = 0.000371634, Final residual = 4.85611e-07, No Iterations 16
time step continuity errors : sum local = 1.27679e-10, global = 4.92939e-12, cumulative = 4.38093e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000885078, Final residual = 1.60739e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00186908, Final residual = 9.31394e-06, No Iterations 3
ExecutionTime = 15.22 s ClockTime = 15 s
Time = 1.4875
Courant Number mean: 0.12219 max: 0.616943
smoothSolver: Solving for Ux, Initial residual = 0.000911703, Final residual = 1.6463e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00187743, Final residual = 5.66843e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00197782, Final residual = 0.000180133, No Iterations 4
time step continuity errors : sum local = 4.73594e-08, global = 2.0648e-09, cumulative = 4.383e-06
GAMG: Solving for p, Initial residual = 0.000374916, Final residual = 5.03487e-07, No Iterations 16
time step continuity errors : sum local = 1.32404e-10, global = 4.99055e-12, cumulative = 4.383e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000885306, Final residual = 1.60631e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0018675, Final residual = 9.31662e-06, No Iterations 3
ExecutionTime = 15.24 s ClockTime = 15 s
Time = 1.49
Courant Number mean: 0.122244 max: 0.616942
smoothSolver: Solving for Ux, Initial residual = 0.000911199, Final residual = 1.64618e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00187966, Final residual = 5.68116e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00196901, Final residual = 0.000179567, No Iterations 4
time step continuity errors : sum local = 4.72213e-08, global = 1.89526e-09, cumulative = 4.3849e-06
GAMG: Solving for p, Initial residual = 0.000372383, Final residual = 4.66012e-07, No Iterations 16
time step continuity errors : sum local = 1.22579e-10, global = 4.78588e-12, cumulative = 4.3849e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00088569, Final residual = 1.60997e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00186593, Final residual = 9.31281e-06, No Iterations 3
ExecutionTime = 15.26 s ClockTime = 15 s
Time = 1.4925
Courant Number mean: 0.122297 max: 0.61694
smoothSolver: Solving for Ux, Initial residual = 0.0009107, Final residual = 1.64473e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00188156, Final residual = 5.69264e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00197399, Final residual = 0.000177601, No Iterations 4
time step continuity errors : sum local = 4.67139e-08, global = 2.26768e-09, cumulative = 4.38717e-06
GAMG: Solving for p, Initial residual = 0.000370339, Final residual = 5.11761e-07, No Iterations 16
time step continuity errors : sum local = 1.3464e-10, global = 5.1675e-12, cumulative = 4.38718e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000886248, Final residual = 1.61099e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00186455, Final residual = 9.31744e-06, No Iterations 3
ExecutionTime = 15.29 s ClockTime = 15 s
Time = 1.495
Courant Number mean: 0.122351 max: 0.616939
smoothSolver: Solving for Ux, Initial residual = 0.000910197, Final residual = 1.6456e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00188337, Final residual = 5.70443e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00195245, Final residual = 0.000177217, No Iterations 4
time step continuity errors : sum local = 4.66226e-08, global = 1.93684e-09, cumulative = 4.38911e-06
GAMG: Solving for p, Initial residual = 0.00036758, Final residual = 4.78778e-07, No Iterations 16
time step continuity errors : sum local = 1.25988e-10, global = 4.88894e-12, cumulative = 4.38912e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000887104, Final residual = 1.61013e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00186319, Final residual = 9.30921e-06, No Iterations 3
ExecutionTime = 15.31 s ClockTime = 15 s
Time = 1.4975
Courant Number mean: 0.122403 max: 0.616937
smoothSolver: Solving for Ux, Initial residual = 0.000909624, Final residual = 1.64428e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00188511, Final residual = 5.71627e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00203456, Final residual = 0.00017874, No Iterations 4
time step continuity errors : sum local = 4.70333e-08, global = 2.18081e-09, cumulative = 4.3913e-06
GAMG: Solving for p, Initial residual = 0.000372518, Final residual = 4.92715e-07, No Iterations 16
time step continuity errors : sum local = 1.29684e-10, global = 4.94013e-12, cumulative = 4.3913e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000888034, Final residual = 1.61101e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00186181, Final residual = 9.29536e-06, No Iterations 3
ExecutionTime = 15.33 s ClockTime = 15 s
Time = 1.5
Courant Number mean: 0.122456 max: 0.616935
smoothSolver: Solving for Ux, Initial residual = 0.000909068, Final residual = 1.64471e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00188697, Final residual = 5.72821e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00199012, Final residual = 0.000175106, No Iterations 4
time step continuity errors : sum local = 4.6086e-08, global = 2.17813e-09, cumulative = 4.39348e-06
GAMG: Solving for p, Initial residual = 0.000373246, Final residual = 4.90304e-07, No Iterations 16
time step continuity errors : sum local = 1.29071e-10, global = 4.95177e-12, cumulative = 4.39349e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000888915, Final residual = 1.62542e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00186043, Final residual = 9.29759e-06, No Iterations 3
ExecutionTime = 15.38 s ClockTime = 15 s
Time = 1.5025
Courant Number mean: 0.122508 max: 0.616934
smoothSolver: Solving for Ux, Initial residual = 0.000908528, Final residual = 1.64402e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00188927, Final residual = 5.7416e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00198571, Final residual = 0.00017572, No Iterations 4
time step continuity errors : sum local = 4.62531e-08, global = 2.1026e-09, cumulative = 4.39559e-06
GAMG: Solving for p, Initial residual = 0.000371706, Final residual = 5.11066e-07, No Iterations 16
time step continuity errors : sum local = 1.34545e-10, global = 5.16068e-12, cumulative = 4.39559e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00088976, Final residual = 1.6231e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00185917, Final residual = 9.28178e-06, No Iterations 3
ExecutionTime = 15.4 s ClockTime = 16 s
Time = 1.505
Courant Number mean: 0.122559 max: 0.616932
smoothSolver: Solving for Ux, Initial residual = 0.000908038, Final residual = 1.64449e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00189192, Final residual = 5.75647e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00188491, Final residual = 0.000175392, No Iterations 4
time step continuity errors : sum local = 4.61712e-08, global = 2.20493e-09, cumulative = 4.3978e-06
GAMG: Solving for p, Initial residual = 0.000368271, Final residual = 4.94365e-07, No Iterations 16
time step continuity errors : sum local = 1.30165e-10, global = 5.01267e-12, cumulative = 4.3978e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000890606, Final residual = 1.62697e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00185802, Final residual = 9.27035e-06, No Iterations 3
ExecutionTime = 15.42 s ClockTime = 16 s
Time = 1.5075
Courant Number mean: 0.12261 max: 0.616931
smoothSolver: Solving for Ux, Initial residual = 0.000907592, Final residual = 9.99799e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00189423, Final residual = 5.771e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00189195, Final residual = 0.000169406, No Iterations 4
time step continuity errors : sum local = 4.45993e-08, global = -4.80804e-11, cumulative = 4.39776e-06
GAMG: Solving for p, Initial residual = 0.000346624, Final residual = 8.64033e-07, No Iterations 13
time step continuity errors : sum local = 2.27496e-10, global = 7.26013e-12, cumulative = 4.39776e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000891416, Final residual = 1.62777e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00185687, Final residual = 9.26543e-06, No Iterations 3
ExecutionTime = 15.44 s ClockTime = 16 s
Time = 1.51
Courant Number mean: 0.122661 max: 0.616929
smoothSolver: Solving for Ux, Initial residual = 0.000907137, Final residual = 1.64746e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00189651, Final residual = 5.7864e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00192463, Final residual = 0.000174084, No Iterations 4
time step continuity errors : sum local = 4.58325e-08, global = 3.09526e-09, cumulative = 4.40086e-06
GAMG: Solving for p, Initial residual = 0.000366077, Final residual = 5.45202e-07, No Iterations 16
time step continuity errors : sum local = 1.43564e-10, global = 5.36111e-12, cumulative = 4.40086e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000892296, Final residual = 1.63067e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00185559, Final residual = 9.28633e-06, No Iterations 3
ExecutionTime = 15.46 s ClockTime = 16 s
Time = 1.5125
Courant Number mean: 0.122711 max: 0.616928
smoothSolver: Solving for Ux, Initial residual = 0.000906583, Final residual = 9.9905e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00189845, Final residual = 5.80017e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00186129, Final residual = 0.000171557, No Iterations 4
time step continuity errors : sum local = 4.51727e-08, global = -9.19647e-10, cumulative = 4.39994e-06
GAMG: Solving for p, Initial residual = 0.000347285, Final residual = 4.64769e-07, No Iterations 15
time step continuity errors : sum local = 1.22394e-10, global = 3.99906e-12, cumulative = 4.39995e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000893271, Final residual = 1.62999e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00185428, Final residual = 9.26855e-06, No Iterations 3
ExecutionTime = 15.49 s ClockTime = 16 s
Time = 1.515
Courant Number mean: 0.12276 max: 0.616926
smoothSolver: Solving for Ux, Initial residual = 0.000906142, Final residual = 9.99739e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00190041, Final residual = 5.81529e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00186185, Final residual = 0.000169664, No Iterations 4
time step continuity errors : sum local = 4.46826e-08, global = 2.23284e-09, cumulative = 4.40218e-06
GAMG: Solving for p, Initial residual = 0.000346943, Final residual = 7.79319e-07, No Iterations 14
time step continuity errors : sum local = 2.05287e-10, global = 7.69699e-12, cumulative = 4.40219e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000894232, Final residual = 1.63095e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00185288, Final residual = 9.27049e-06, No Iterations 3
ExecutionTime = 15.51 s ClockTime = 16 s
Time = 1.5175
Courant Number mean: 0.12281 max: 0.616925
smoothSolver: Solving for Ux, Initial residual = 0.000905626, Final residual = 9.98505e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00190206, Final residual = 5.82817e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00189703, Final residual = 0.000169516, No Iterations 4
time step continuity errors : sum local = 4.46536e-08, global = 9.25921e-10, cumulative = 4.40312e-06
GAMG: Solving for p, Initial residual = 0.00034872, Final residual = 6.3896e-07, No Iterations 14
time step continuity errors : sum local = 1.68354e-10, global = 5.93635e-12, cumulative = 4.40312e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000895228, Final residual = 1.63184e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00185149, Final residual = 9.25814e-06, No Iterations 3
ExecutionTime = 15.54 s ClockTime = 16 s
Time = 1.52
Courant Number mean: 0.122862 max: 0.616923
smoothSolver: Solving for Ux, Initial residual = 0.00090515, Final residual = 9.98685e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00190351, Final residual = 5.84343e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00201859, Final residual = 0.000171376, No Iterations 4
time step continuity errors : sum local = 4.51571e-08, global = 1.30622e-09, cumulative = 4.40443e-06
GAMG: Solving for p, Initial residual = 0.000355868, Final residual = 7.35612e-07, No Iterations 14
time step continuity errors : sum local = 1.93882e-10, global = 7.5521e-12, cumulative = 4.40444e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000896192, Final residual = 1.63284e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00185008, Final residual = 9.24782e-06, No Iterations 3
ExecutionTime = 15.56 s ClockTime = 16 s
Time = 1.5225
Courant Number mean: 0.122914 max: 0.616922
smoothSolver: Solving for Ux, Initial residual = 0.000904664, Final residual = 9.97901e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00190462, Final residual = 5.85654e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00209323, Final residual = 0.000171331, No Iterations 4
time step continuity errors : sum local = 4.51513e-08, global = 1.33981e-09, cumulative = 4.40577e-06
GAMG: Solving for p, Initial residual = 0.000363233, Final residual = 7.31581e-07, No Iterations 14
time step continuity errors : sum local = 1.92822e-10, global = 6.65316e-12, cumulative = 4.40578e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00089709, Final residual = 1.64371e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00184872, Final residual = 9.24725e-06, No Iterations 3
ExecutionTime = 15.58 s ClockTime = 16 s
Time = 1.525
Courant Number mean: 0.122966 max: 0.61692
smoothSolver: Solving for Ux, Initial residual = 0.000904123, Final residual = 9.97699e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00190621, Final residual = 5.8721e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00201892, Final residual = 0.000173232, No Iterations 4
time step continuity errors : sum local = 4.56585e-08, global = -8.1036e-10, cumulative = 4.40497e-06
GAMG: Solving for p, Initial residual = 0.000357096, Final residual = 5.27752e-07, No Iterations 15
time step continuity errors : sum local = 1.3912e-10, global = 4.65922e-12, cumulative = 4.40498e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000897878, Final residual = 1.65349e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00184745, Final residual = 9.25435e-06, No Iterations 3
ExecutionTime = 15.61 s ClockTime = 16 s
Time = 1.5275
Courant Number mean: 0.123019 max: 0.616919
smoothSolver: Solving for Ux, Initial residual = 0.000903569, Final residual = 9.97588e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00190759, Final residual = 5.88713e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00203689, Final residual = 0.000173832, No Iterations 4
time step continuity errors : sum local = 4.58269e-08, global = 1.54888e-09, cumulative = 4.40652e-06
GAMG: Solving for p, Initial residual = 0.000355978, Final residual = 7.80578e-07, No Iterations 14
time step continuity errors : sum local = 2.05832e-10, global = 7.68137e-12, cumulative = 4.40653e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000898561, Final residual = 1.65595e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00184617, Final residual = 9.24619e-06, No Iterations 3
ExecutionTime = 15.63 s ClockTime = 16 s
Time = 1.53
Courant Number mean: 0.123072 max: 0.616918
smoothSolver: Solving for Ux, Initial residual = 0.000903063, Final residual = 9.9645e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00190863, Final residual = 5.90022e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00205689, Final residual = 0.000171518, No Iterations 4
time step continuity errors : sum local = 4.52313e-08, global = 3.77597e-10, cumulative = 4.40691e-06
GAMG: Solving for p, Initial residual = 0.000358231, Final residual = 8.99878e-07, No Iterations 13
time step continuity errors : sum local = 2.37373e-10, global = 7.56748e-12, cumulative = 4.40692e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000899273, Final residual = 1.66044e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00184499, Final residual = 9.25645e-06, No Iterations 3
ExecutionTime = 15.65 s ClockTime = 16 s
Time = 1.5325
Courant Number mean: 0.123124 max: 0.616916
smoothSolver: Solving for Ux, Initial residual = 0.000902629, Final residual = 9.96503e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00190992, Final residual = 5.91569e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00208947, Final residual = 0.000173439, No Iterations 4
time step continuity errors : sum local = 4.57524e-08, global = 1.6846e-09, cumulative = 4.4086e-06
GAMG: Solving for p, Initial residual = 0.000362896, Final residual = 7.71817e-07, No Iterations 14
time step continuity errors : sum local = 2.03655e-10, global = 8.09417e-12, cumulative = 4.40861e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000899868, Final residual = 1.65851e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00184381, Final residual = 9.25119e-06, No Iterations 3
ExecutionTime = 15.68 s ClockTime = 16 s
Time = 1.535
Courant Number mean: 0.123177 max: 0.616915
smoothSolver: Solving for Ux, Initial residual = 0.000902193, Final residual = 9.95889e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00191034, Final residual = 5.93097e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00216667, Final residual = 0.000170113, No Iterations 4
time step continuity errors : sum local = 4.48888e-08, global = 1.13392e-09, cumulative = 4.40974e-06
GAMG: Solving for p, Initial residual = 0.000362073, Final residual = 6.80284e-07, No Iterations 14
time step continuity errors : sum local = 1.79553e-10, global = 6.59863e-12, cumulative = 4.40975e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00090054, Final residual = 1.65849e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0018426, Final residual = 9.25061e-06, No Iterations 3
ExecutionTime = 15.7 s ClockTime = 16 s
Time = 1.5375
Courant Number mean: 0.123229 max: 0.616913
smoothSolver: Solving for Ux, Initial residual = 0.000901772, Final residual = 9.9623e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00191126, Final residual = 5.94801e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00222423, Final residual = 0.000185973, No Iterations 4
time step continuity errors : sum local = 4.90834e-08, global = 9.77162e-10, cumulative = 4.41073e-06
GAMG: Solving for p, Initial residual = 0.000368769, Final residual = 6.87365e-07, No Iterations 14
time step continuity errors : sum local = 1.81432e-10, global = 6.25719e-12, cumulative = 4.41073e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000901201, Final residual = 1.66237e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00184134, Final residual = 9.25569e-06, No Iterations 3
ExecutionTime = 15.73 s ClockTime = 16 s
Time = 1.54
Courant Number mean: 0.123282 max: 0.616912
smoothSolver: Solving for Ux, Initial residual = 0.000901267, Final residual = 9.95641e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.0019126, Final residual = 5.96442e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00208557, Final residual = 0.000176565, No Iterations 4
time step continuity errors : sum local = 4.65994e-08, global = 1.36769e-09, cumulative = 4.4121e-06
GAMG: Solving for p, Initial residual = 0.000355557, Final residual = 7.31319e-07, No Iterations 14
time step continuity errors : sum local = 1.93032e-10, global = 6.93918e-12, cumulative = 4.41211e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00090182, Final residual = 1.66365e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00183998, Final residual = 9.24635e-06, No Iterations 3
ExecutionTime = 15.75 s ClockTime = 16 s
Time = 1.5425
Courant Number mean: 0.123334 max: 0.61691
smoothSolver: Solving for Ux, Initial residual = 0.000900849, Final residual = 9.95341e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00191428, Final residual = 5.97949e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00204338, Final residual = 0.000177124, No Iterations 4
time step continuity errors : sum local = 4.6747e-08, global = 1.18337e-09, cumulative = 4.41329e-06
GAMG: Solving for p, Initial residual = 0.000355871, Final residual = 7.11015e-07, No Iterations 14
time step continuity errors : sum local = 1.87679e-10, global = 6.68712e-12, cumulative = 4.4133e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000902443, Final residual = 1.66465e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00183858, Final residual = 9.23868e-06, No Iterations 3
ExecutionTime = 15.77 s ClockTime = 16 s
Time = 1.545
Courant Number mean: 0.123386 max: 0.616909
smoothSolver: Solving for Ux, Initial residual = 0.000900403, Final residual = 9.95034e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00191649, Final residual = 5.99472e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00205631, Final residual = 0.000178438, No Iterations 4
time step continuity errors : sum local = 4.7096e-08, global = 1.16699e-09, cumulative = 4.41447e-06
GAMG: Solving for p, Initial residual = 0.000356493, Final residual = 7.14638e-07, No Iterations 14
time step continuity errors : sum local = 1.88648e-10, global = 6.63608e-12, cumulative = 4.41447e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000903057, Final residual = 1.66606e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00183711, Final residual = 9.24025e-06, No Iterations 3
ExecutionTime = 15.79 s ClockTime = 16 s
Time = 1.5475
Courant Number mean: 0.123437 max: 0.616908
smoothSolver: Solving for Ux, Initial residual = 0.000899942, Final residual = 9.94778e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00191872, Final residual = 6.00979e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00209467, Final residual = 0.000182678, No Iterations 4
time step continuity errors : sum local = 4.82175e-08, global = 1.21081e-09, cumulative = 4.41568e-06
GAMG: Solving for p, Initial residual = 0.00036358, Final residual = 7.12299e-07, No Iterations 14
time step continuity errors : sum local = 1.88036e-10, global = 6.93414e-12, cumulative = 4.41569e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000903647, Final residual = 1.68289e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00183566, Final residual = 9.2326e-06, No Iterations 3
ExecutionTime = 15.82 s ClockTime = 16 s
Time = 1.55
Courant Number mean: 0.123489 max: 0.616906
smoothSolver: Solving for Ux, Initial residual = 0.000899484, Final residual = 9.94531e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00192032, Final residual = 6.0236e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00209701, Final residual = 0.000179016, No Iterations 4
time step continuity errors : sum local = 4.72538e-08, global = 1.15821e-09, cumulative = 4.41685e-06
GAMG: Solving for p, Initial residual = 0.000362666, Final residual = 7.16061e-07, No Iterations 14
time step continuity errors : sum local = 1.89049e-10, global = 6.55585e-12, cumulative = 4.41686e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000904131, Final residual = 1.68057e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00183415, Final residual = 9.22589e-06, No Iterations 3
ExecutionTime = 15.84 s ClockTime = 16 s
Time = 1.5525
Courant Number mean: 0.12354 max: 0.616905
smoothSolver: Solving for Ux, Initial residual = 0.000898997, Final residual = 9.944e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00192253, Final residual = 6.03905e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00200502, Final residual = 0.000179577, No Iterations 4
time step continuity errors : sum local = 4.74057e-08, global = 1.12518e-09, cumulative = 4.41798e-06
GAMG: Solving for p, Initial residual = 0.000357893, Final residual = 7.20517e-07, No Iterations 14
time step continuity errors : sum local = 1.90237e-10, global = 6.63006e-12, cumulative = 4.41799e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000904597, Final residual = 1.68539e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00183265, Final residual = 9.22173e-06, No Iterations 3
ExecutionTime = 15.86 s ClockTime = 16 s
Time = 1.555
Courant Number mean: 0.12359 max: 0.616903
smoothSolver: Solving for Ux, Initial residual = 0.000898467, Final residual = 9.93872e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00192497, Final residual = 6.05467e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00192755, Final residual = 0.000181361, No Iterations 4
time step continuity errors : sum local = 4.78838e-08, global = 1.18568e-09, cumulative = 4.41917e-06
GAMG: Solving for p, Initial residual = 0.000350994, Final residual = 7.09628e-07, No Iterations 14
time step continuity errors : sum local = 1.87403e-10, global = 6.64626e-12, cumulative = 4.41918e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000905184, Final residual = 1.68662e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00183135, Final residual = 9.25223e-06, No Iterations 3
ExecutionTime = 15.88 s ClockTime = 16 s
Time = 1.5575
Courant Number mean: 0.123641 max: 0.616902
smoothSolver: Solving for Ux, Initial residual = 0.00089795, Final residual = 9.93677e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00192711, Final residual = 6.06911e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00195375, Final residual = 0.000182521, No Iterations 4
time step continuity errors : sum local = 4.81994e-08, global = 1.13018e-09, cumulative = 4.42031e-06
GAMG: Solving for p, Initial residual = 0.000351494, Final residual = 7.03885e-07, No Iterations 14
time step continuity errors : sum local = 1.85917e-10, global = 6.52526e-12, cumulative = 4.42032e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00090586, Final residual = 1.68917e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00183017, Final residual = 9.237e-06, No Iterations 3
ExecutionTime = 15.91 s ClockTime = 16 s
Time = 1.56
Courant Number mean: 0.123691 max: 0.616901
smoothSolver: Solving for Ux, Initial residual = 0.000897467, Final residual = 9.93458e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00192915, Final residual = 6.08355e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00198819, Final residual = 0.000182203, No Iterations 4
time step continuity errors : sum local = 4.81219e-08, global = 1.1348e-09, cumulative = 4.42145e-06
GAMG: Solving for p, Initial residual = 0.000353053, Final residual = 6.99726e-07, No Iterations 14
time step continuity errors : sum local = 1.84838e-10, global = 6.52792e-12, cumulative = 4.42146e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000906471, Final residual = 1.69034e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00182904, Final residual = 9.24435e-06, No Iterations 3
ExecutionTime = 15.93 s ClockTime = 16 s
Time = 1.5625
Courant Number mean: 0.12374 max: 0.616899
smoothSolver: Solving for Ux, Initial residual = 0.000896979, Final residual = 9.93285e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.0019308, Final residual = 6.09819e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00200218, Final residual = 0.000183344, No Iterations 4
time step continuity errors : sum local = 4.84306e-08, global = 1.07364e-09, cumulative = 4.42253e-06
GAMG: Solving for p, Initial residual = 0.000353774, Final residual = 6.86295e-07, No Iterations 14
time step continuity errors : sum local = 1.81326e-10, global = 6.36235e-12, cumulative = 4.42254e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000907062, Final residual = 1.69109e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00182803, Final residual = 9.22483e-06, No Iterations 3
ExecutionTime = 15.95 s ClockTime = 16 s
Time = 1.565
Courant Number mean: 0.123789 max: 0.616898
smoothSolver: Solving for Ux, Initial residual = 0.000896476, Final residual = 9.93107e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00193234, Final residual = 6.11233e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0020453, Final residual = 0.000184061, No Iterations 4
time step continuity errors : sum local = 4.86315e-08, global = 1.02504e-09, cumulative = 4.42356e-06
GAMG: Solving for p, Initial residual = 0.000356714, Final residual = 6.7298e-07, No Iterations 14
time step continuity errors : sum local = 1.77858e-10, global = 6.27161e-12, cumulative = 4.42357e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000907803, Final residual = 1.69331e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00182702, Final residual = 9.22088e-06, No Iterations 3
ExecutionTime = 15.98 s ClockTime = 16 s
Time = 1.5675
Courant Number mean: 0.123838 max: 0.616896
smoothSolver: Solving for Ux, Initial residual = 0.000896014, Final residual = 9.92961e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00193355, Final residual = 6.12668e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00203728, Final residual = 0.00018253, No Iterations 4
time step continuity errors : sum local = 4.8238e-08, global = 1.00179e-09, cumulative = 4.42457e-06
GAMG: Solving for p, Initial residual = 0.000353583, Final residual = 6.7e-07, No Iterations 14
time step continuity errors : sum local = 1.77103e-10, global = 6.18248e-12, cumulative = 4.42458e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000908722, Final residual = 1.69501e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00182601, Final residual = 9.21529e-06, No Iterations 3
ExecutionTime = 16 s ClockTime = 16 s
Time = 1.57
Courant Number mean: 0.123886 max: 0.616895
smoothSolver: Solving for Ux, Initial residual = 0.000895541, Final residual = 9.92775e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00193487, Final residual = 6.14064e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00200687, Final residual = 0.000184251, No Iterations 4
time step continuity errors : sum local = 4.86991e-08, global = 9.90299e-10, cumulative = 4.42557e-06
GAMG: Solving for p, Initial residual = 0.000354771, Final residual = 6.61689e-07, No Iterations 14
time step continuity errors : sum local = 1.74919e-10, global = 6.10573e-12, cumulative = 4.42557e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000909681, Final residual = 1.71122e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00182499, Final residual = 9.22599e-06, No Iterations 3
ExecutionTime = 16.02 s ClockTime = 16 s
Time = 1.5725
Courant Number mean: 0.123933 max: 0.616894
smoothSolver: Solving for Ux, Initial residual = 0.00089507, Final residual = 9.92728e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00193606, Final residual = 6.15449e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00205749, Final residual = 0.000185511, No Iterations 4
time step continuity errors : sum local = 4.90389e-08, global = 9.73537e-10, cumulative = 4.42655e-06
GAMG: Solving for p, Initial residual = 0.000359855, Final residual = 6.48896e-07, No Iterations 14
time step continuity errors : sum local = 1.71572e-10, global = 5.95459e-12, cumulative = 4.42655e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000910837, Final residual = 1.71894e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00182393, Final residual = 9.21964e-06, No Iterations 3
ExecutionTime = 16.04 s ClockTime = 16 s
Time = 1.575
Courant Number mean: 0.12398 max: 0.616892
smoothSolver: Solving for Ux, Initial residual = 0.000894591, Final residual = 9.92644e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00193748, Final residual = 6.16849e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00206188, Final residual = 0.000183257, No Iterations 4
time step continuity errors : sum local = 4.84507e-08, global = 9.43548e-10, cumulative = 4.4275e-06
GAMG: Solving for p, Initial residual = 0.000359684, Final residual = 6.53266e-07, No Iterations 14
time step continuity errors : sum local = 1.72748e-10, global = 5.95789e-12, cumulative = 4.4275e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00091205, Final residual = 1.72317e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0018229, Final residual = 9.21497e-06, No Iterations 3
ExecutionTime = 16.06 s ClockTime = 16 s
Time = 1.5775
Courant Number mean: 0.124027 max: 0.616891
smoothSolver: Solving for Ux, Initial residual = 0.000894089, Final residual = 9.92431e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00193896, Final residual = 6.18349e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00213183, Final residual = 0.000184872, No Iterations 4
time step continuity errors : sum local = 4.88869e-08, global = 8.81022e-10, cumulative = 4.42838e-06
GAMG: Solving for p, Initial residual = 0.000361179, Final residual = 6.16999e-07, No Iterations 14
time step continuity errors : sum local = 1.6319e-10, global = 5.60776e-12, cumulative = 4.42839e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000913236, Final residual = 1.72804e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0018218, Final residual = 9.22615e-06, No Iterations 3
ExecutionTime = 16.09 s ClockTime = 16 s
Time = 1.58
Courant Number mean: 0.124073 max: 0.61689
smoothSolver: Solving for Ux, Initial residual = 0.000893596, Final residual = 9.92292e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00194037, Final residual = 6.19841e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00213192, Final residual = 0.000185324, No Iterations 4
time step continuity errors : sum local = 4.90129e-08, global = 9.14881e-10, cumulative = 4.4293e-06
GAMG: Solving for p, Initial residual = 0.00035753, Final residual = 6.32422e-07, No Iterations 14
time step continuity errors : sum local = 1.67288e-10, global = 5.70559e-12, cumulative = 4.42931e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000914352, Final residual = 1.72649e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00182068, Final residual = 9.236e-06, No Iterations 3
ExecutionTime = 16.11 s ClockTime = 16 s
Time = 1.5825
Courant Number mean: 0.124119 max: 0.616888
smoothSolver: Solving for Ux, Initial residual = 0.000893114, Final residual = 9.923e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00194185, Final residual = 6.21385e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00204282, Final residual = 0.000184573, No Iterations 4
time step continuity errors : sum local = 4.8821e-08, global = 8.93669e-10, cumulative = 4.4302e-06
GAMG: Solving for p, Initial residual = 0.000352752, Final residual = 6.17556e-07, No Iterations 14
time step continuity errors : sum local = 1.63382e-10, global = 5.58501e-12, cumulative = 4.43021e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000915486, Final residual = 1.72651e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00181958, Final residual = 9.24203e-06, No Iterations 3
ExecutionTime = 16.13 s ClockTime = 16 s
Time = 1.585
Courant Number mean: 0.124164 max: 0.616887
smoothSolver: Solving for Ux, Initial residual = 0.000892604, Final residual = 9.92186e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00194329, Final residual = 6.23048e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00204841, Final residual = 0.000184781, No Iterations 4
time step continuity errors : sum local = 4.88849e-08, global = 9.20713e-10, cumulative = 4.43113e-06
GAMG: Solving for p, Initial residual = 0.000354866, Final residual = 6.2452e-07, No Iterations 14
time step continuity errors : sum local = 1.65255e-10, global = 5.63738e-12, cumulative = 4.43113e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000916655, Final residual = 1.72946e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00181847, Final residual = 9.23263e-06, No Iterations 3
ExecutionTime = 16.16 s ClockTime = 16 s
Time = 1.5875
Courant Number mean: 0.12421 max: 0.616886
smoothSolver: Solving for Ux, Initial residual = 0.000892079, Final residual = 9.92016e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00194459, Final residual = 6.2486e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00213304, Final residual = 0.000182682, No Iterations 4
time step continuity errors : sum local = 4.8341e-08, global = 7.7719e-10, cumulative = 4.43191e-06
GAMG: Solving for p, Initial residual = 0.00035588, Final residual = 5.67261e-07, No Iterations 14
time step continuity errors : sum local = 1.50143e-10, global = 5.08309e-12, cumulative = 4.43192e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000917753, Final residual = 1.73349e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00181739, Final residual = 9.22899e-06, No Iterations 3
ExecutionTime = 16.18 s ClockTime = 16 s
Time = 1.59
Courant Number mean: 0.124257 max: 0.616884
smoothSolver: Solving for Ux, Initial residual = 0.000891632, Final residual = 9.91856e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00194607, Final residual = 6.26786e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00218766, Final residual = 0.000193145, No Iterations 4
time step continuity errors : sum local = 5.11228e-08, global = 1.18197e-09, cumulative = 4.4331e-06
GAMG: Solving for p, Initial residual = 0.000371068, Final residual = 6.86563e-07, No Iterations 14
time step continuity errors : sum local = 1.81757e-10, global = 6.15805e-12, cumulative = 4.43311e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000918785, Final residual = 1.73508e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00181634, Final residual = 9.22859e-06, No Iterations 3
ExecutionTime = 16.2 s ClockTime = 16 s
Time = 1.5925
Courant Number mean: 0.124305 max: 0.616883
smoothSolver: Solving for Ux, Initial residual = 0.000891129, Final residual = 9.91586e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00194707, Final residual = 6.28763e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00202951, Final residual = 0.000184678, No Iterations 4
time step continuity errors : sum local = 4.88907e-08, global = 9.87588e-10, cumulative = 4.43409e-06
GAMG: Solving for p, Initial residual = 0.000352243, Final residual = 6.2921e-07, No Iterations 14
time step continuity errors : sum local = 1.666e-10, global = 5.71305e-12, cumulative = 4.4341e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000919684, Final residual = 1.73801e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00181529, Final residual = 9.23727e-06, No Iterations 3
ExecutionTime = 16.23 s ClockTime = 16 s
Time = 1.595
Courant Number mean: 0.124353 max: 0.616882
smoothSolver: Solving for Ux, Initial residual = 0.000890687, Final residual = 9.91486e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00194841, Final residual = 6.30565e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00206991, Final residual = 0.000184735, No Iterations 4
time step continuity errors : sum local = 4.89106e-08, global = 9.75599e-10, cumulative = 4.43507e-06
GAMG: Solving for p, Initial residual = 0.000351545, Final residual = 6.28088e-07, No Iterations 14
time step continuity errors : sum local = 1.66325e-10, global = 5.67219e-12, cumulative = 4.43508e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000920534, Final residual = 1.74177e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00181423, Final residual = 9.23479e-06, No Iterations 3
ExecutionTime = 16.26 s ClockTime = 16 s
Time = 1.5975
Courant Number mean: 0.124401 max: 0.61688
smoothSolver: Solving for Ux, Initial residual = 0.000890225, Final residual = 9.91433e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00195, Final residual = 6.32394e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0020601, Final residual = 0.000183887, No Iterations 4
time step continuity errors : sum local = 4.86937e-08, global = 6.63419e-10, cumulative = 4.43574e-06
GAMG: Solving for p, Initial residual = 0.000349342, Final residual = 5.32658e-07, No Iterations 14
time step continuity errors : sum local = 1.41079e-10, global = 5.37327e-12, cumulative = 4.43575e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000921539, Final residual = 1.75876e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00181325, Final residual = 9.23113e-06, No Iterations 3
ExecutionTime = 16.28 s ClockTime = 16 s
Time = 1.6
Courant Number mean: 0.124449 max: 0.616879
smoothSolver: Solving for Ux, Initial residual = 0.000889711, Final residual = 9.91235e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.0019515, Final residual = 6.34176e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00204002, Final residual = 0.000184726, No Iterations 4
time step continuity errors : sum local = 4.89264e-08, global = 8.41349e-10, cumulative = 4.43659e-06
GAMG: Solving for p, Initial residual = 0.000351417, Final residual = 5.86356e-07, No Iterations 14
time step continuity errors : sum local = 1.5534e-10, global = 5.31907e-12, cumulative = 4.4366e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000922445, Final residual = 1.76458e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00181222, Final residual = 9.24948e-06, No Iterations 3
ExecutionTime = 16.33 s ClockTime = 16 s
Time = 1.6025
Courant Number mean: 0.124497 max: 0.616878
smoothSolver: Solving for Ux, Initial residual = 0.000889198, Final residual = 9.91115e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.0019527, Final residual = 6.3587e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00209679, Final residual = 0.00018609, No Iterations 4
time step continuity errors : sum local = 4.92982e-08, global = 7.71781e-10, cumulative = 4.43737e-06
GAMG: Solving for p, Initial residual = 0.000356338, Final residual = 5.58603e-07, No Iterations 14
time step continuity errors : sum local = 1.48014e-10, global = 5.39109e-12, cumulative = 4.43737e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000923274, Final residual = 1.76472e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00181113, Final residual = 9.25981e-06, No Iterations 3
ExecutionTime = 16.36 s ClockTime = 16 s
Time = 1.605
Courant Number mean: 0.124546 max: 0.616877
smoothSolver: Solving for Ux, Initial residual = 0.000888717, Final residual = 9.91123e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00195416, Final residual = 6.37511e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00218356, Final residual = 0.000182792, No Iterations 4
time step continuity errors : sum local = 4.84276e-08, global = 6.34891e-10, cumulative = 4.43801e-06
GAMG: Solving for p, Initial residual = 0.000359122, Final residual = 5.41927e-07, No Iterations 14
time step continuity errors : sum local = 1.43591e-10, global = 5.16817e-12, cumulative = 4.43801e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00092406, Final residual = 1.76908e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0018099, Final residual = 9.25095e-06, No Iterations 3
ExecutionTime = 16.38 s ClockTime = 16 s
Time = 1.6075
Courant Number mean: 0.124594 max: 0.616875
smoothSolver: Solving for Ux, Initial residual = 0.000888206, Final residual = 9.90856e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00195602, Final residual = 6.39299e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00216746, Final residual = 0.000183288, No Iterations 4
time step continuity errors : sum local = 4.85614e-08, global = 8.30771e-10, cumulative = 4.43884e-06
GAMG: Solving for p, Initial residual = 0.000352297, Final residual = 5.88763e-07, No Iterations 14
time step continuity errors : sum local = 1.56009e-10, global = 5.31185e-12, cumulative = 4.43885e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000924837, Final residual = 1.77116e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00180868, Final residual = 9.26014e-06, No Iterations 3
ExecutionTime = 16.4 s ClockTime = 17 s
Time = 1.61
Courant Number mean: 0.124642 max: 0.616874
smoothSolver: Solving for Ux, Initial residual = 0.000887747, Final residual = 9.90806e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00195809, Final residual = 6.41021e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0022303, Final residual = 0.000181767, No Iterations 4
time step continuity errors : sum local = 4.81609e-08, global = 4.68344e-10, cumulative = 4.43932e-06
GAMG: Solving for p, Initial residual = 0.000352805, Final residual = 8.71567e-07, No Iterations 13
time step continuity errors : sum local = 2.30969e-10, global = 7.88101e-12, cumulative = 4.43932e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000925648, Final residual = 1.77339e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0018074, Final residual = 9.25531e-06, No Iterations 3
ExecutionTime = 16.42 s ClockTime = 17 s
Time = 1.6125
Courant Number mean: 0.124691 max: 0.616873
smoothSolver: Solving for Ux, Initial residual = 0.00088727, Final residual = 9.90844e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.0019601, Final residual = 6.42717e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00212499, Final residual = 0.000184939, No Iterations 4
time step continuity errors : sum local = 4.90049e-08, global = 5.11469e-10, cumulative = 4.43984e-06
GAMG: Solving for p, Initial residual = 0.000355073, Final residual = 8.80175e-07, No Iterations 13
time step continuity errors : sum local = 2.33255e-10, global = 8.44535e-12, cumulative = 4.43984e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000926356, Final residual = 1.77399e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00180623, Final residual = 9.24797e-06, No Iterations 3
ExecutionTime = 16.44 s ClockTime = 17 s
Time = 1.615
Courant Number mean: 0.124739 max: 0.616872
smoothSolver: Solving for Ux, Initial residual = 0.000886808, Final residual = 9.90855e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00196241, Final residual = 6.44382e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00207591, Final residual = 0.000182886, No Iterations 4
time step continuity errors : sum local = 4.84639e-08, global = 1.41592e-09, cumulative = 4.44126e-06
GAMG: Solving for p, Initial residual = 0.000352307, Final residual = 6.86235e-07, No Iterations 14
time step continuity errors : sum local = 1.81884e-10, global = 5.83449e-12, cumulative = 4.44127e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000927009, Final residual = 1.77709e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00180503, Final residual = 9.25351e-06, No Iterations 3
ExecutionTime = 16.47 s ClockTime = 17 s
Time = 1.6175
Courant Number mean: 0.124786 max: 0.61687
smoothSolver: Solving for Ux, Initial residual = 0.000886338, Final residual = 9.91146e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00196488, Final residual = 6.46179e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0021105, Final residual = 0.00018301, No Iterations 4
time step continuity errors : sum local = 4.8499e-08, global = 2.055e-10, cumulative = 4.44147e-06
GAMG: Solving for p, Initial residual = 0.000351276, Final residual = 8.72694e-07, No Iterations 13
time step continuity errors : sum local = 2.31289e-10, global = 7.67952e-12, cumulative = 4.44148e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000927698, Final residual = 1.78768e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00180383, Final residual = 9.26167e-06, No Iterations 3
ExecutionTime = 16.49 s ClockTime = 17 s
Time = 1.62
Courant Number mean: 0.124834 max: 0.616869
smoothSolver: Solving for Ux, Initial residual = 0.000885861, Final residual = 9.90855e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00196702, Final residual = 6.47744e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00207629, Final residual = 0.00018318, No Iterations 4
time step continuity errors : sum local = 4.85429e-08, global = 9.56482e-10, cumulative = 4.44244e-06
GAMG: Solving for p, Initial residual = 0.000351332, Final residual = 6.4502e-07, No Iterations 14
time step continuity errors : sum local = 1.70956e-10, global = 5.74738e-12, cumulative = 4.44244e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000928557, Final residual = 1.79773e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00180281, Final residual = 9.26114e-06, No Iterations 3
ExecutionTime = 16.51 s ClockTime = 17 s
Time = 1.6225
Courant Number mean: 0.12488 max: 0.616868
smoothSolver: Solving for Ux, Initial residual = 0.000885365, Final residual = 9.9125e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00196884, Final residual = 6.49378e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00208327, Final residual = 0.000180787, No Iterations 4
time step continuity errors : sum local = 4.79155e-08, global = 3.86524e-10, cumulative = 4.44283e-06
GAMG: Solving for p, Initial residual = 0.000351919, Final residual = 8.83601e-07, No Iterations 13
time step continuity errors : sum local = 2.34235e-10, global = 8.03809e-12, cumulative = 4.44284e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000929454, Final residual = 1.80522e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00180188, Final residual = 9.27939e-06, No Iterations 3
ExecutionTime = 16.53 s ClockTime = 17 s
Time = 1.625
Courant Number mean: 0.124927 max: 0.616867
smoothSolver: Solving for Ux, Initial residual = 0.000884854, Final residual = 9.91075e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00197052, Final residual = 6.50958e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00219262, Final residual = 0.00018238, No Iterations 4
time step continuity errors : sum local = 4.83467e-08, global = 9.03917e-10, cumulative = 4.44374e-06
GAMG: Solving for p, Initial residual = 0.000362365, Final residual = 6.25381e-07, No Iterations 14
time step continuity errors : sum local = 1.65814e-10, global = 5.58994e-12, cumulative = 4.44375e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000930308, Final residual = 1.80496e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00180097, Final residual = 9.28462e-06, No Iterations 3
ExecutionTime = 16.56 s ClockTime = 17 s
Time = 1.6275
Courant Number mean: 0.124973 max: 0.616866
smoothSolver: Solving for Ux, Initial residual = 0.000884397, Final residual = 9.91323e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00197204, Final residual = 6.5263e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00225085, Final residual = 0.00018206, No Iterations 4
time step continuity errors : sum local = 4.82735e-08, global = 4.89803e-10, cumulative = 4.44424e-06
GAMG: Solving for p, Initial residual = 0.000366078, Final residual = 8.71849e-07, No Iterations 13
time step continuity errors : sum local = 2.31235e-10, global = 8.94198e-12, cumulative = 4.44424e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00093117, Final residual = 1.81553e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00180016, Final residual = 9.28533e-06, No Iterations 3
ExecutionTime = 16.58 s ClockTime = 17 s
Time = 1.63
Courant Number mean: 0.125018 max: 0.616865
smoothSolver: Solving for Ux, Initial residual = 0.000883965, Final residual = 9.91345e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00197314, Final residual = 6.54191e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0022821, Final residual = 0.000181582, No Iterations 4
time step continuity errors : sum local = 4.81572e-08, global = 6.78086e-10, cumulative = 4.44492e-06
GAMG: Solving for p, Initial residual = 0.000366029, Final residual = 5.48957e-07, No Iterations 14
time step continuity errors : sum local = 1.45618e-10, global = 5.12787e-12, cumulative = 4.44493e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000931954, Final residual = 1.81723e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179933, Final residual = 9.29422e-06, No Iterations 3
ExecutionTime = 16.6 s ClockTime = 17 s
Time = 1.6325
Courant Number mean: 0.125064 max: 0.616864
smoothSolver: Solving for Ux, Initial residual = 0.000883468, Final residual = 9.91523e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00197451, Final residual = 6.55992e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00223416, Final residual = 0.000181882, No Iterations 4
time step continuity errors : sum local = 4.82484e-08, global = 4.28401e-10, cumulative = 4.44536e-06
GAMG: Solving for p, Initial residual = 0.000359332, Final residual = 8.7484e-07, No Iterations 13
time step continuity errors : sum local = 2.32129e-10, global = 8.04759e-12, cumulative = 4.44536e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000932852, Final residual = 1.81788e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179843, Final residual = 9.28981e-06, No Iterations 3
ExecutionTime = 16.62 s ClockTime = 17 s
Time = 1.635
Courant Number mean: 0.125109 max: 0.616862
smoothSolver: Solving for Ux, Initial residual = 0.000882999, Final residual = 9.91543e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00197534, Final residual = 6.57741e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00226067, Final residual = 0.000183487, No Iterations 4
time step continuity errors : sum local = 4.86895e-08, global = 5.24487e-10, cumulative = 4.44589e-06
GAMG: Solving for p, Initial residual = 0.000359173, Final residual = 8.46241e-07, No Iterations 13
time step continuity errors : sum local = 2.24611e-10, global = 8.31028e-12, cumulative = 4.4459e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000934001, Final residual = 1.82053e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179749, Final residual = 9.29101e-06, No Iterations 3
ExecutionTime = 16.64 s ClockTime = 17 s
Time = 1.6375
Courant Number mean: 0.125153 max: 0.616861
smoothSolver: Solving for Ux, Initial residual = 0.00088253, Final residual = 9.91721e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00197611, Final residual = 6.59492e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00224986, Final residual = 0.000179114, No Iterations 4
time step continuity errors : sum local = 4.75421e-08, global = 7.99006e-10, cumulative = 4.4467e-06
GAMG: Solving for p, Initial residual = 0.000357673, Final residual = 5.83569e-07, No Iterations 14
time step continuity errors : sum local = 1.54936e-10, global = 5.44614e-12, cumulative = 4.4467e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000935267, Final residual = 1.82629e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179658, Final residual = 9.2966e-06, No Iterations 3
ExecutionTime = 16.67 s ClockTime = 17 s
Time = 1.64
Courant Number mean: 0.125197 max: 0.61686
smoothSolver: Solving for Ux, Initial residual = 0.000882072, Final residual = 9.91863e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00197675, Final residual = 6.61302e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00225513, Final residual = 0.000179383, No Iterations 4
time step continuity errors : sum local = 4.76262e-08, global = 3.56166e-10, cumulative = 4.44706e-06
GAMG: Solving for p, Initial residual = 0.000360415, Final residual = 8.5124e-07, No Iterations 13
time step continuity errors : sum local = 2.26057e-10, global = 8.21525e-12, cumulative = 4.44707e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000936568, Final residual = 1.82965e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179568, Final residual = 9.31929e-06, No Iterations 3
ExecutionTime = 16.68 s ClockTime = 17 s
Time = 1.6425
Courant Number mean: 0.125241 max: 0.616859
smoothSolver: Solving for Ux, Initial residual = 0.000881623, Final residual = 9.91995e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00197696, Final residual = 6.631e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0023071, Final residual = 0.000185274, No Iterations 4
time step continuity errors : sum local = 4.91989e-08, global = 2.65929e-10, cumulative = 4.44733e-06
GAMG: Solving for p, Initial residual = 0.000369314, Final residual = 9.70798e-07, No Iterations 13
time step continuity errors : sum local = 2.57821e-10, global = 8.01308e-12, cumulative = 4.44734e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000937849, Final residual = 1.83342e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179488, Final residual = 9.32433e-06, No Iterations 3
ExecutionTime = 16.72 s ClockTime = 17 s
Time = 1.645
Courant Number mean: 0.125285 max: 0.616858
smoothSolver: Solving for Ux, Initial residual = 0.000880998, Final residual = 9.91941e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00197797, Final residual = 6.65313e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00209645, Final residual = 0.000179984, No Iterations 4
time step continuity errors : sum local = 4.78058e-08, global = 2.62352e-10, cumulative = 4.4476e-06
GAMG: Solving for p, Initial residual = 0.000351847, Final residual = 8.81338e-07, No Iterations 13
time step continuity errors : sum local = 2.34138e-10, global = 8.07973e-12, cumulative = 4.44761e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000939085, Final residual = 1.83752e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017941, Final residual = 9.32951e-06, No Iterations 3
ExecutionTime = 16.74 s ClockTime = 17 s
Time = 1.6475
Courant Number mean: 0.125328 max: 0.616857
smoothSolver: Solving for Ux, Initial residual = 0.000880515, Final residual = 9.91914e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00197906, Final residual = 6.67208e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00213158, Final residual = 0.000179386, No Iterations 4
time step continuity errors : sum local = 4.76576e-08, global = 3.26069e-10, cumulative = 4.44794e-06
GAMG: Solving for p, Initial residual = 0.000353905, Final residual = 8.65275e-07, No Iterations 13
time step continuity errors : sum local = 2.29932e-10, global = 7.59788e-12, cumulative = 4.44794e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000940279, Final residual = 1.85974e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179334, Final residual = 9.34833e-06, No Iterations 3
ExecutionTime = 16.76 s ClockTime = 17 s
Time = 1.65
Courant Number mean: 0.12537 max: 0.616856
smoothSolver: Solving for Ux, Initial residual = 0.000880123, Final residual = 9.92249e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00198036, Final residual = 6.69117e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0021867, Final residual = 0.000181673, No Iterations 4
time step continuity errors : sum local = 4.827e-08, global = 1.70073e-10, cumulative = 4.44811e-06
GAMG: Solving for p, Initial residual = 0.000356396, Final residual = 8.54962e-07, No Iterations 13
time step continuity errors : sum local = 2.27179e-10, global = 7.80192e-12, cumulative = 4.44812e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000941403, Final residual = 1.86593e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179259, Final residual = 9.37103e-06, No Iterations 3
ExecutionTime = 16.78 s ClockTime = 17 s
Time = 1.6525
Courant Number mean: 0.125413 max: 0.616855
smoothSolver: Solving for Ux, Initial residual = 0.000879698, Final residual = 9.92361e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00198182, Final residual = 6.70921e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00209897, Final residual = 0.00018023, No Iterations 4
time step continuity errors : sum local = 4.78886e-08, global = 2.21745e-10, cumulative = 4.44834e-06
GAMG: Solving for p, Initial residual = 0.000348225, Final residual = 8.6791e-07, No Iterations 13
time step continuity errors : sum local = 2.30655e-10, global = 7.45173e-12, cumulative = 4.44835e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000942464, Final residual = 1.86666e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179181, Final residual = 9.37399e-06, No Iterations 3
ExecutionTime = 16.81 s ClockTime = 17 s
Time = 1.655
Courant Number mean: 0.125454 max: 0.616854
smoothSolver: Solving for Ux, Initial residual = 0.000879241, Final residual = 9.92733e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00198383, Final residual = 6.72842e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00208429, Final residual = 0.000180479, No Iterations 4
time step continuity errors : sum local = 4.79646e-08, global = -9.84399e-13, cumulative = 4.44835e-06
GAMG: Solving for p, Initial residual = 0.000348383, Final residual = 8.78038e-07, No Iterations 13
time step continuity errors : sum local = 2.33402e-10, global = 7.58375e-12, cumulative = 4.44836e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000943609, Final residual = 1.87294e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179103, Final residual = 9.38615e-06, No Iterations 3
ExecutionTime = 16.83 s ClockTime = 17 s
Time = 1.6575
Courant Number mean: 0.125496 max: 0.616853
smoothSolver: Solving for Ux, Initial residual = 0.000878743, Final residual = 9.92848e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00198582, Final residual = 6.74733e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0021678, Final residual = 0.000185469, No Iterations 4
time step continuity errors : sum local = 4.93037e-08, global = -1.19764e-10, cumulative = 4.44824e-06
GAMG: Solving for p, Initial residual = 0.000360784, Final residual = 8.83603e-07, No Iterations 13
time step continuity errors : sum local = 2.34949e-10, global = 7.87885e-12, cumulative = 4.44825e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000944767, Final residual = 1.87502e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179023, Final residual = 9.38759e-06, No Iterations 3
ExecutionTime = 16.85 s ClockTime = 17 s
Time = 1.66
Courant Number mean: 0.125537 max: 0.616852
smoothSolver: Solving for Ux, Initial residual = 0.000878292, Final residual = 9.93323e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00198762, Final residual = 6.76512e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00222524, Final residual = 0.000173145, No Iterations 4
time step continuity errors : sum local = 4.60302e-08, global = 9.19656e-10, cumulative = 4.44917e-06
GAMG: Solving for p, Initial residual = 0.000361759, Final residual = 6.27363e-07, No Iterations 14
time step continuity errors : sum local = 1.66795e-10, global = 5.65689e-12, cumulative = 4.44917e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000945861, Final residual = 1.87733e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178946, Final residual = 9.39134e-06, No Iterations 3
ExecutionTime = 16.87 s ClockTime = 17 s
Time = 1.6625
Courant Number mean: 0.125581 max: 0.616851
smoothSolver: Solving for Ux, Initial residual = 0.000877702, Final residual = 9.93426e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00199018, Final residual = 6.78585e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00214311, Final residual = 0.00018042, No Iterations 4
time step continuity errors : sum local = 4.79631e-08, global = -7.77935e-10, cumulative = 4.44839e-06
GAMG: Solving for p, Initial residual = 0.000352947, Final residual = 9.57635e-07, No Iterations 13
time step continuity errors : sum local = 2.54602e-10, global = 7.98787e-12, cumulative = 4.4484e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000946928, Final residual = 1.88147e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178871, Final residual = 9.40592e-06, No Iterations 3
ExecutionTime = 16.9 s ClockTime = 17 s
Time = 1.665
Courant Number mean: 0.125624 max: 0.61685
smoothSolver: Solving for Ux, Initial residual = 0.000877229, Final residual = 9.93439e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00199242, Final residual = 6.80452e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00220144, Final residual = 0.000178289, No Iterations 4
time step continuity errors : sum local = 4.73964e-08, global = 3.69401e-10, cumulative = 4.44877e-06
GAMG: Solving for p, Initial residual = 0.00035194, Final residual = 8.50126e-07, No Iterations 13
time step continuity errors : sum local = 2.26029e-10, global = 7.9223e-12, cumulative = 4.44878e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000947941, Final residual = 1.88624e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178786, Final residual = 9.4315e-06, No Iterations 3
ExecutionTime = 16.93 s ClockTime = 17 s
Time = 1.6675
Courant Number mean: 0.125668 max: 0.616849
smoothSolver: Solving for Ux, Initial residual = 0.000876771, Final residual = 9.93715e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00199467, Final residual = 6.8232e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0022258, Final residual = 0.000179392, No Iterations 4
time step continuity errors : sum local = 4.76943e-08, global = -2.23313e-10, cumulative = 4.44856e-06
GAMG: Solving for p, Initial residual = 0.000353559, Final residual = 8.84038e-07, No Iterations 13
time step continuity errors : sum local = 2.35081e-10, global = 7.51416e-12, cumulative = 4.44856e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000948808, Final residual = 1.89424e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178702, Final residual = 9.4403e-06, No Iterations 3
ExecutionTime = 16.96 s ClockTime = 17 s
Time = 1.67
Courant Number mean: 0.125712 max: 0.616848
smoothSolver: Solving for Ux, Initial residual = 0.000876324, Final residual = 9.94025e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.0019966, Final residual = 6.84235e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00220805, Final residual = 0.000178379, No Iterations 4
time step continuity errors : sum local = 4.74303e-08, global = 3.89085e-11, cumulative = 4.4486e-06
GAMG: Solving for p, Initial residual = 0.000354802, Final residual = 8.58062e-07, No Iterations 13
time step continuity errors : sum local = 2.28188e-10, global = 7.7001e-12, cumulative = 4.44861e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000949808, Final residual = 1.89856e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178613, Final residual = 9.46837e-06, No Iterations 3
ExecutionTime = 16.98 s ClockTime = 17 s
Time = 1.6725
Courant Number mean: 0.125756 max: 0.616846
smoothSolver: Solving for Ux, Initial residual = 0.000875872, Final residual = 9.94421e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00199835, Final residual = 6.86139e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00220818, Final residual = 0.000179214, No Iterations 4
time step continuity errors : sum local = 4.76576e-08, global = -4.0235e-10, cumulative = 4.44821e-06
GAMG: Solving for p, Initial residual = 0.000352357, Final residual = 8.93418e-07, No Iterations 13
time step continuity errors : sum local = 2.37626e-10, global = 7.47397e-12, cumulative = 4.44821e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000950823, Final residual = 1.9181e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178525, Final residual = 9.48838e-06, No Iterations 3
ExecutionTime = 17.01 s ClockTime = 17 s
Time = 1.675
Courant Number mean: 0.125801 max: 0.616845
smoothSolver: Solving for Ux, Initial residual = 0.000875367, Final residual = 9.9476e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.0020001, Final residual = 6.88165e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00231482, Final residual = 0.000177769, No Iterations 4
time step continuity errors : sum local = 4.72779e-08, global = -4.10417e-10, cumulative = 4.4478e-06
GAMG: Solving for p, Initial residual = 0.000362515, Final residual = 9.08226e-07, No Iterations 13
time step continuity errors : sum local = 2.41577e-10, global = 7.6515e-12, cumulative = 4.44781e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000951784, Final residual = 1.931e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178441, Final residual = 9.49981e-06, No Iterations 3
ExecutionTime = 17.03 s ClockTime = 17 s
Time = 1.6775
Courant Number mean: 0.125845 max: 0.616844
smoothSolver: Solving for Ux, Initial residual = 0.000874882, Final residual = 9.94996e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.0020019, Final residual = 6.9007e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00238304, Final residual = 0.000178662, No Iterations 4
time step continuity errors : sum local = 4.75159e-08, global = -3.86469e-10, cumulative = 4.44743e-06
GAMG: Solving for p, Initial residual = 0.000365159, Final residual = 8.92914e-07, No Iterations 13
time step continuity errors : sum local = 2.375e-10, global = 7.48683e-12, cumulative = 4.44743e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000952647, Final residual = 1.93146e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178379, Final residual = 9.50305e-06, No Iterations 3
ExecutionTime = 17.05 s ClockTime = 17 s
Time = 1.68
Courant Number mean: 0.125889 max: 0.616843
smoothSolver: Solving for Ux, Initial residual = 0.000874417, Final residual = 9.95355e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00200343, Final residual = 6.91968e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00236965, Final residual = 0.000178932, No Iterations 4
time step continuity errors : sum local = 4.75895e-08, global = -5.58382e-10, cumulative = 4.44687e-06
GAMG: Solving for p, Initial residual = 0.000366295, Final residual = 9.15336e-07, No Iterations 13
time step continuity errors : sum local = 2.43485e-10, global = 7.61551e-12, cumulative = 4.44688e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000953592, Final residual = 1.93896e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178316, Final residual = 9.53293e-06, No Iterations 3
ExecutionTime = 17.07 s ClockTime = 17 s
Time = 1.6825
Courant Number mean: 0.125933 max: 0.616842
smoothSolver: Solving for Ux, Initial residual = 0.000873947, Final residual = 9.95709e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00200495, Final residual = 6.93882e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00245674, Final residual = 0.000182988, No Iterations 4
time step continuity errors : sum local = 4.86752e-08, global = -7.93415e-10, cumulative = 4.44609e-06
GAMG: Solving for p, Initial residual = 0.0003736, Final residual = 9.65454e-07, No Iterations 13
time step continuity errors : sum local = 2.56854e-10, global = 8.15475e-12, cumulative = 4.4461e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000954624, Final residual = 1.94109e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178246, Final residual = 9.54922e-06, No Iterations 3
ExecutionTime = 17.09 s ClockTime = 17 s
Time = 1.685
Courant Number mean: 0.125977 max: 0.616841
smoothSolver: Solving for Ux, Initial residual = 0.000873548, Final residual = 9.96115e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00200603, Final residual = 6.95778e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00238753, Final residual = 0.000171781, No Iterations 4
time step continuity errors : sum local = 4.56976e-08, global = 7.68602e-10, cumulative = 4.44687e-06
GAMG: Solving for p, Initial residual = 0.000369304, Final residual = 5.46049e-07, No Iterations 14
time step continuity errors : sum local = 1.45282e-10, global = 5.52541e-12, cumulative = 4.44687e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000955759, Final residual = 1.94594e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178172, Final residual = 9.55651e-06, No Iterations 3
ExecutionTime = 17.11 s ClockTime = 17 s
Time = 1.6875
Courant Number mean: 0.126021 max: 0.61684
smoothSolver: Solving for Ux, Initial residual = 0.000873083, Final residual = 9.96485e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00200765, Final residual = 6.97837e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00234525, Final residual = 0.000176869, No Iterations 4
time step continuity errors : sum local = 4.70533e-08, global = -1.32478e-09, cumulative = 4.44555e-06
GAMG: Solving for p, Initial residual = 0.000369428, Final residual = 4.9744e-07, No Iterations 15
time step continuity errors : sum local = 1.32355e-10, global = 4.58692e-12, cumulative = 4.44555e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000956996, Final residual = 1.95361e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178096, Final residual = 9.57976e-06, No Iterations 3
ExecutionTime = 17.13 s ClockTime = 17 s
Time = 1.69
Courant Number mean: 0.126064 max: 0.616839
smoothSolver: Solving for Ux, Initial residual = 0.000872633, Final residual = 9.96964e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00200876, Final residual = 6.99811e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00227082, Final residual = 0.000176611, No Iterations 4
time step continuity errors : sum local = 4.69886e-08, global = -2.66615e-10, cumulative = 4.44528e-06
GAMG: Solving for p, Initial residual = 0.000365667, Final residual = 8.62683e-07, No Iterations 13
time step continuity errors : sum local = 2.29564e-10, global = 7.80071e-12, cumulative = 4.44529e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000958208, Final residual = 1.95832e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017801, Final residual = 9.59444e-06, No Iterations 3
ExecutionTime = 17.15 s ClockTime = 17 s
Time = 1.6925
Courant Number mean: 0.126107 max: 0.616838
smoothSolver: Solving for Ux, Initial residual = 0.000872161, Final residual = 9.97472e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00200975, Final residual = 7.01922e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00219779, Final residual = 0.000176303, No Iterations 4
time step continuity errors : sum local = 4.69167e-08, global = -8.46454e-10, cumulative = 4.44445e-06
GAMG: Solving for p, Initial residual = 0.000360192, Final residual = 9.45503e-07, No Iterations 13
time step continuity errors : sum local = 2.51668e-10, global = 8.49613e-12, cumulative = 4.44445e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000959344, Final residual = 1.96419e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017794, Final residual = 9.61132e-06, No Iterations 3
ExecutionTime = 17.17 s ClockTime = 17 s
Time = 1.695
Courant Number mean: 0.12615 max: 0.616837
smoothSolver: Solving for Ux, Initial residual = 0.000871665, Final residual = 9.97996e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00201073, Final residual = 7.03968e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00228097, Final residual = 0.000173995, No Iterations 4
time step continuity errors : sum local = 4.6312e-08, global = -4.90067e-10, cumulative = 4.44396e-06
GAMG: Solving for p, Initial residual = 0.000364491, Final residual = 8.85637e-07, No Iterations 13
time step continuity errors : sum local = 2.35782e-10, global = 8.44827e-12, cumulative = 4.44397e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000960421, Final residual = 1.97397e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177879, Final residual = 9.65683e-06, No Iterations 3
ExecutionTime = 17.2 s ClockTime = 17 s
Time = 1.6975
Courant Number mean: 0.126193 max: 0.616836
smoothSolver: Solving for Ux, Initial residual = 0.000871287, Final residual = 9.98587e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.0020113, Final residual = 7.06009e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00230433, Final residual = 0.000183127, No Iterations 4
time step continuity errors : sum local = 4.87508e-08, global = -7.07416e-10, cumulative = 4.44326e-06
GAMG: Solving for p, Initial residual = 0.00037411, Final residual = 9.61578e-07, No Iterations 13
time step continuity errors : sum local = 2.56015e-10, global = 7.52367e-12, cumulative = 4.44327e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000961475, Final residual = 1.98115e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177815, Final residual = 9.67678e-06, No Iterations 3
ExecutionTime = 17.22 s ClockTime = 17 s
Time = 1.7
Courant Number mean: 0.126235 max: 0.616835
smoothSolver: Solving for Ux, Initial residual = 0.00087076, Final residual = 9.98851e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00201226, Final residual = 7.08354e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00214327, Final residual = 0.000176998, No Iterations 4
time step continuity errors : sum local = 4.71299e-08, global = -9.0476e-10, cumulative = 4.44237e-06
GAMG: Solving for p, Initial residual = 0.00036001, Final residual = 9.57273e-07, No Iterations 13
time step continuity errors : sum local = 2.54947e-10, global = 8.83524e-12, cumulative = 4.44238e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000962575, Final residual = 2.00743e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017775, Final residual = 9.71408e-06, No Iterations 3
ExecutionTime = 17.26 s ClockTime = 17 s
Time = 1.7025
Courant Number mean: 0.126277 max: 0.616834
smoothSolver: Solving for Ux, Initial residual = 0.000870301, Final residual = 9.98926e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00201308, Final residual = 7.103e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00215852, Final residual = 0.000176372, No Iterations 4
time step continuity errors : sum local = 4.69708e-08, global = -5.30002e-10, cumulative = 4.44185e-06
GAMG: Solving for p, Initial residual = 0.000358875, Final residual = 8.99928e-07, No Iterations 13
time step continuity errors : sum local = 2.39711e-10, global = 8.0357e-12, cumulative = 4.44185e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000963884, Final residual = 2.00949e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177683, Final residual = 9.74169e-06, No Iterations 3
ExecutionTime = 17.29 s ClockTime = 17 s
Time = 1.705
Courant Number mean: 0.126319 max: 0.616833
smoothSolver: Solving for Ux, Initial residual = 0.000869829, Final residual = 9.99483e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00201433, Final residual = 7.12303e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00219381, Final residual = 0.000177573, No Iterations 4
time step continuity errors : sum local = 4.72962e-08, global = -3.76009e-10, cumulative = 4.44148e-06
GAMG: Solving for p, Initial residual = 0.000362007, Final residual = 8.90552e-07, No Iterations 13
time step continuity errors : sum local = 2.37231e-10, global = 7.97915e-12, cumulative = 4.44149e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000965307, Final residual = 2.01817e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177619, Final residual = 9.75435e-06, No Iterations 3
ExecutionTime = 17.31 s ClockTime = 17 s
Time = 1.7075
Courant Number mean: 0.12636 max: 0.616832
smoothSolver: Solving for Ux, Initial residual = 0.000869316, Final residual = 9.99828e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00201601, Final residual = 7.14268e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00219043, Final residual = 0.000181016, No Iterations 4
time step continuity errors : sum local = 4.82177e-08, global = -2.10649e-09, cumulative = 4.43938e-06
GAMG: Solving for p, Initial residual = 0.00036579, Final residual = 5.10913e-07, No Iterations 15
time step continuity errors : sum local = 1.36111e-10, global = 4.63223e-12, cumulative = 4.43938e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000966741, Final residual = 2.0215e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177563, Final residual = 9.78029e-06, No Iterations 3
ExecutionTime = 17.33 s ClockTime = 17 s
Time = 1.71
Courant Number mean: 0.126401 max: 0.616831
smoothSolver: Solving for Ux, Initial residual = 0.000868875, Final residual = 1.76523e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00201757, Final residual = 7.1623e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00220468, Final residual = 0.000188732, No Iterations 4
time step continuity errors : sum local = 5.02821e-08, global = 6.90671e-10, cumulative = 4.44008e-06
GAMG: Solving for p, Initial residual = 0.000380153, Final residual = 8.90604e-07, No Iterations 14
time step continuity errors : sum local = 2.37341e-10, global = 1.00622e-11, cumulative = 4.44009e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00096813, Final residual = 2.02846e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177513, Final residual = 9.80278e-06, No Iterations 3
ExecutionTime = 17.36 s ClockTime = 17 s
Time = 1.7125
Courant Number mean: 0.126441 max: 0.616831
smoothSolver: Solving for Ux, Initial residual = 0.00086835, Final residual = 1.765e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00201954, Final residual = 7.1807e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00228244, Final residual = 0.000186689, No Iterations 4
time step continuity errors : sum local = 4.9753e-08, global = -3.35282e-10, cumulative = 4.43975e-06
GAMG: Solving for p, Initial residual = 0.000386065, Final residual = 7.22477e-07, No Iterations 15
time step continuity errors : sum local = 1.92599e-10, global = 8.14976e-12, cumulative = 4.43976e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00096961, Final residual = 2.03541e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177466, Final residual = 9.82869e-06, No Iterations 3
ExecutionTime = 17.38 s ClockTime = 18 s
Time = 1.715
Courant Number mean: 0.126482 max: 0.61683
smoothSolver: Solving for Ux, Initial residual = 0.000867932, Final residual = 1.76917e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00202137, Final residual = 7.19911e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00239478, Final residual = 0.000183576, No Iterations 4
time step continuity errors : sum local = 4.8928e-08, global = 8.08835e-10, cumulative = 4.44057e-06
GAMG: Solving for p, Initial residual = 0.000397735, Final residual = 4.92078e-07, No Iterations 16
time step continuity errors : sum local = 1.31166e-10, global = 5.60351e-12, cumulative = 4.44057e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000970934, Final residual = 2.04291e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177416, Final residual = 9.85714e-06, No Iterations 3
ExecutionTime = 17.4 s ClockTime = 18 s
Time = 1.7175
Courant Number mean: 0.126522 max: 0.616829
smoothSolver: Solving for Ux, Initial residual = 0.000867398, Final residual = 1.77199e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0020242, Final residual = 7.22043e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00238772, Final residual = 0.000193141, No Iterations 4
time step continuity errors : sum local = 5.14787e-08, global = -7.88723e-10, cumulative = 4.43978e-06
GAMG: Solving for p, Initial residual = 0.000398803, Final residual = 7.56783e-07, No Iterations 15
time step continuity errors : sum local = 2.01749e-10, global = 8.44282e-12, cumulative = 4.43979e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000972202, Final residual = 2.05354e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177367, Final residual = 9.89898e-06, No Iterations 3
ExecutionTime = 17.42 s ClockTime = 18 s
Time = 1.72
Courant Number mean: 0.126561 max: 0.616828
smoothSolver: Solving for Ux, Initial residual = 0.000866963, Final residual = 1.77478e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00202638, Final residual = 7.23999e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00241606, Final residual = 0.000189058, No Iterations 4
time step continuity errors : sum local = 5.03897e-08, global = 5.91841e-10, cumulative = 4.44038e-06
GAMG: Solving for p, Initial residual = 0.000394548, Final residual = 8.55758e-07, No Iterations 14
time step continuity errors : sum local = 2.28107e-10, global = 9.60249e-12, cumulative = 4.44039e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000973381, Final residual = 2.06274e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177318, Final residual = 9.96352e-06, No Iterations 3
ExecutionTime = 17.45 s ClockTime = 18 s
Time = 1.7225
Courant Number mean: 0.1266 max: 0.616827
smoothSolver: Solving for Ux, Initial residual = 0.000866466, Final residual = 1.77847e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00202863, Final residual = 7.2602e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00237775, Final residual = 0.000188982, No Iterations 4
time step continuity errors : sum local = 5.03652e-08, global = -4.35371e-10, cumulative = 4.43996e-06
GAMG: Solving for p, Initial residual = 0.00039229, Final residual = 7.47474e-07, No Iterations 15
time step continuity errors : sum local = 1.99235e-10, global = 8.45787e-12, cumulative = 4.43997e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000974578, Final residual = 2.07069e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177271, Final residual = 9.98376e-06, No Iterations 3
ExecutionTime = 17.47 s ClockTime = 18 s
Time = 1.725
Courant Number mean: 0.126639 max: 0.616826
smoothSolver: Solving for Ux, Initial residual = 0.000866001, Final residual = 1.78154e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00203052, Final residual = 7.28023e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00245398, Final residual = 0.000187512, No Iterations 4
time step continuity errors : sum local = 4.99748e-08, global = 3.33837e-10, cumulative = 4.4403e-06
GAMG: Solving for p, Initial residual = 0.000398695, Final residual = 9.613e-07, No Iterations 13
time step continuity errors : sum local = 2.56252e-10, global = 9.96457e-12, cumulative = 4.44031e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000975708, Final residual = 2.09259e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177216, Final residual = 2.43831e-06, No Iterations 4
ExecutionTime = 17.49 s ClockTime = 18 s
Time = 1.7275
Courant Number mean: 0.126678 max: 0.616825
smoothSolver: Solving for Ux, Initial residual = 0.0008655, Final residual = 1.78534e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00203229, Final residual = 7.30183e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00242686, Final residual = 0.000187558, No Iterations 4
time step continuity errors : sum local = 4.99931e-08, global = 4.65451e-11, cumulative = 4.44036e-06
GAMG: Solving for p, Initial residual = 0.00039806, Final residual = 6.51075e-07, No Iterations 15
time step continuity errors : sum local = 1.73581e-10, global = 7.30368e-12, cumulative = 4.44036e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000976879, Final residual = 2.10667e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177168, Final residual = 2.45314e-06, No Iterations 4
ExecutionTime = 17.52 s ClockTime = 18 s
Time = 1.73
Courant Number mean: 0.126716 max: 0.616824
smoothSolver: Solving for Ux, Initial residual = 0.000865028, Final residual = 1.78859e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00203387, Final residual = 7.32329e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00241297, Final residual = 0.000189954, No Iterations 4
time step continuity errors : sum local = 5.06383e-08, global = -9.69557e-11, cumulative = 4.44027e-06
GAMG: Solving for p, Initial residual = 0.000396263, Final residual = 7.25091e-07, No Iterations 15
time step continuity errors : sum local = 1.93336e-10, global = 8.3484e-12, cumulative = 4.44028e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000978027, Final residual = 2.11339e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177122, Final residual = 2.46792e-06, No Iterations 4
ExecutionTime = 17.54 s ClockTime = 18 s
Time = 1.7325
Courant Number mean: 0.126754 max: 0.616823
smoothSolver: Solving for Ux, Initial residual = 0.000864572, Final residual = 1.79289e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0020354, Final residual = 7.34585e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00238652, Final residual = 0.000189079, No Iterations 4
time step continuity errors : sum local = 5.04089e-08, global = 1.01022e-10, cumulative = 4.44038e-06
GAMG: Solving for p, Initial residual = 0.000389236, Final residual = 6.34561e-07, No Iterations 15
time step continuity errors : sum local = 1.69207e-10, global = 7.10767e-12, cumulative = 4.44038e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000979141, Final residual = 2.12195e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177079, Final residual = 2.4892e-06, No Iterations 4
ExecutionTime = 17.56 s ClockTime = 18 s
Time = 1.735
Courant Number mean: 0.126793 max: 0.616822
smoothSolver: Solving for Ux, Initial residual = 0.000864099, Final residual = 1.79598e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00203663, Final residual = 7.36776e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00238005, Final residual = 0.000190106, No Iterations 4
time step continuity errors : sum local = 5.06828e-08, global = 9.15743e-11, cumulative = 4.44048e-06
GAMG: Solving for p, Initial residual = 0.000393906, Final residual = 6.34523e-07, No Iterations 15
time step continuity errors : sum local = 1.6919e-10, global = 7.13543e-12, cumulative = 4.44048e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00098017, Final residual = 2.1377e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177041, Final residual = 2.50478e-06, No Iterations 4
ExecutionTime = 17.59 s ClockTime = 18 s
Time = 1.7375
Courant Number mean: 0.126833 max: 0.616821
smoothSolver: Solving for Ux, Initial residual = 0.000863588, Final residual = 1.79997e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0020379, Final residual = 7.38972e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00246076, Final residual = 0.000191937, No Iterations 4
time step continuity errors : sum local = 5.11722e-08, global = -3.14215e-11, cumulative = 4.44045e-06
GAMG: Solving for p, Initial residual = 0.000396472, Final residual = 6.73906e-07, No Iterations 15
time step continuity errors : sum local = 1.79707e-10, global = 7.53487e-12, cumulative = 4.44046e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000981265, Final residual = 2.1514e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177011, Final residual = 2.5234e-06, No Iterations 4
ExecutionTime = 17.61 s ClockTime = 18 s
Time = 1.74
Courant Number mean: 0.126873 max: 0.61682
smoothSolver: Solving for Ux, Initial residual = 0.000863142, Final residual = 1.80334e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00203883, Final residual = 7.41247e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00235621, Final residual = 0.000192461, No Iterations 4
time step continuity errors : sum local = 5.13206e-08, global = 9.24839e-11, cumulative = 4.44055e-06
GAMG: Solving for p, Initial residual = 0.00039317, Final residual = 6.23462e-07, No Iterations 15
time step continuity errors : sum local = 1.66286e-10, global = 6.93298e-12, cumulative = 4.44056e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000982443, Final residual = 2.1629e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176971, Final residual = 2.53985e-06, No Iterations 4
ExecutionTime = 17.64 s ClockTime = 18 s
Time = 1.7425
Courant Number mean: 0.126913 max: 0.616819
smoothSolver: Solving for Ux, Initial residual = 0.000862654, Final residual = 1.80753e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00204007, Final residual = 7.43545e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00235672, Final residual = 0.000192542, No Iterations 4
time step continuity errors : sum local = 5.13511e-08, global = -9.19463e-11, cumulative = 4.44047e-06
GAMG: Solving for p, Initial residual = 0.000392272, Final residual = 7.03252e-07, No Iterations 15
time step continuity errors : sum local = 1.87606e-10, global = 7.98525e-12, cumulative = 4.44047e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000983803, Final residual = 2.17431e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176938, Final residual = 2.55935e-06, No Iterations 4
ExecutionTime = 17.66 s ClockTime = 18 s
Time = 1.745
Courant Number mean: 0.126953 max: 0.616819
smoothSolver: Solving for Ux, Initial residual = 0.000862156, Final residual = 1.81085e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0020414, Final residual = 7.45864e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00237174, Final residual = 0.000195541, No Iterations 4
time step continuity errors : sum local = 5.2159e-08, global = -6.13428e-11, cumulative = 4.44041e-06
GAMG: Solving for p, Initial residual = 0.000396131, Final residual = 6.88134e-07, No Iterations 15
time step continuity errors : sum local = 1.83593e-10, global = 7.74028e-12, cumulative = 4.44042e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000985155, Final residual = 2.18736e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.001769, Final residual = 2.58076e-06, No Iterations 4
ExecutionTime = 17.69 s ClockTime = 18 s
Time = 1.7475
Courant Number mean: 0.126994 max: 0.616818
smoothSolver: Solving for Ux, Initial residual = 0.000861768, Final residual = 1.81431e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0020425, Final residual = 7.48312e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00238947, Final residual = 0.00019473, No Iterations 4
time step continuity errors : sum local = 5.19497e-08, global = 1.11082e-10, cumulative = 4.44053e-06
GAMG: Solving for p, Initial residual = 0.000397381, Final residual = 6.28233e-07, No Iterations 15
time step continuity errors : sum local = 1.67628e-10, global = 6.99609e-12, cumulative = 4.44054e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000986518, Final residual = 2.1992e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176859, Final residual = 2.59815e-06, No Iterations 4
ExecutionTime = 17.71 s ClockTime = 18 s
Time = 1.75
Courant Number mean: 0.127034 max: 0.616817
smoothSolver: Solving for Ux, Initial residual = 0.000861334, Final residual = 1.81802e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00204347, Final residual = 7.50595e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00251939, Final residual = 0.000192697, No Iterations 4
time step continuity errors : sum local = 5.14074e-08, global = -2.48587e-10, cumulative = 4.44029e-06
GAMG: Solving for p, Initial residual = 0.000406582, Final residual = 7.72858e-07, No Iterations 15
time step continuity errors : sum local = 2.06212e-10, global = 9.13135e-12, cumulative = 4.4403e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000987746, Final residual = 2.21908e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176819, Final residual = 2.61792e-06, No Iterations 4
ExecutionTime = 17.73 s ClockTime = 18 s
Time = 1.7525
Courant Number mean: 0.127074 max: 0.616816
smoothSolver: Solving for Ux, Initial residual = 0.000860836, Final residual = 1.82221e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00204494, Final residual = 7.53168e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00250058, Final residual = 0.000190953, No Iterations 4
time step continuity errors : sum local = 5.09471e-08, global = -1.71628e-10, cumulative = 4.44013e-06
GAMG: Solving for p, Initial residual = 0.000403354, Final residual = 6.90358e-07, No Iterations 15
time step continuity errors : sum local = 1.84221e-10, global = 7.71861e-12, cumulative = 4.44014e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000989003, Final residual = 2.22903e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176782, Final residual = 2.64242e-06, No Iterations 4
ExecutionTime = 17.76 s ClockTime = 18 s
Time = 1.755
Courant Number mean: 0.127115 max: 0.616815
smoothSolver: Solving for Ux, Initial residual = 0.000860441, Final residual = 1.82533e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00204633, Final residual = 7.5553e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00256696, Final residual = 0.000202176, No Iterations 4
time step continuity errors : sum local = 5.39507e-08, global = 3.00144e-10, cumulative = 4.44044e-06
GAMG: Solving for p, Initial residual = 0.000408609, Final residual = 4.87864e-07, No Iterations 15
time step continuity errors : sum local = 1.30216e-10, global = 5.50595e-12, cumulative = 4.44044e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00099037, Final residual = 2.26011e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176743, Final residual = 2.66242e-06, No Iterations 4
ExecutionTime = 17.78 s ClockTime = 18 s
Time = 1.7575
Courant Number mean: 0.127155 max: 0.616814
smoothSolver: Solving for Ux, Initial residual = 0.000860026, Final residual = 1.83026e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00204834, Final residual = 7.58013e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00238328, Final residual = 0.000196761, No Iterations 4
time step continuity errors : sum local = 5.2517e-08, global = -2.56896e-10, cumulative = 4.44018e-06
GAMG: Solving for p, Initial residual = 0.000396173, Final residual = 7.12015e-07, No Iterations 15
time step continuity errors : sum local = 1.90085e-10, global = 8.0145e-12, cumulative = 4.44019e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000991874, Final residual = 2.26797e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176716, Final residual = 2.68249e-06, No Iterations 4
ExecutionTime = 17.8 s ClockTime = 18 s
Time = 1.76
Courant Number mean: 0.127195 max: 0.616813
smoothSolver: Solving for Ux, Initial residual = 0.000859626, Final residual = 1.83306e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00205049, Final residual = 7.60226e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00238637, Final residual = 0.000195746, No Iterations 4
time step continuity errors : sum local = 5.22528e-08, global = 2.34725e-10, cumulative = 4.44043e-06
GAMG: Solving for p, Initial residual = 0.000392716, Final residual = 5.80697e-07, No Iterations 15
time step continuity errors : sum local = 1.55044e-10, global = 6.4967e-12, cumulative = 4.44043e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000993314, Final residual = 2.27809e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176687, Final residual = 2.70158e-06, No Iterations 4
ExecutionTime = 17.83 s ClockTime = 18 s
Time = 1.7625
Courant Number mean: 0.127235 max: 0.616813
smoothSolver: Solving for Ux, Initial residual = 0.000859186, Final residual = 1.83807e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00205275, Final residual = 7.62478e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00238735, Final residual = 0.000196614, No Iterations 4
time step continuity errors : sum local = 5.24865e-08, global = -1.02321e-10, cumulative = 4.44033e-06
GAMG: Solving for p, Initial residual = 0.000393479, Final residual = 7.11341e-07, No Iterations 15
time step continuity errors : sum local = 1.89917e-10, global = 8.11582e-12, cumulative = 4.44034e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000994709, Final residual = 2.28965e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176658, Final residual = 2.7229e-06, No Iterations 4
ExecutionTime = 17.85 s ClockTime = 18 s
Time = 1.765
Courant Number mean: 0.127275 max: 0.616812
smoothSolver: Solving for Ux, Initial residual = 0.000858681, Final residual = 1.84167e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00205488, Final residual = 7.64685e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00232671, Final residual = 0.000195655, No Iterations 4
time step continuity errors : sum local = 5.22319e-08, global = 3.67228e-11, cumulative = 4.44038e-06
GAMG: Solving for p, Initial residual = 0.000389893, Final residual = 6.89106e-07, No Iterations 15
time step continuity errors : sum local = 1.84e-10, global = 7.88639e-12, cumulative = 4.44038e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000995995, Final residual = 2.30355e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176629, Final residual = 2.74381e-06, No Iterations 4
ExecutionTime = 17.87 s ClockTime = 18 s
Time = 1.7675
Courant Number mean: 0.127314 max: 0.616811
smoothSolver: Solving for Ux, Initial residual = 0.000858185, Final residual = 1.84655e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00205705, Final residual = 7.66909e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00230063, Final residual = 0.000197602, No Iterations 4
time step continuity errors : sum local = 5.27598e-08, global = -1.43914e-10, cumulative = 4.44024e-06
GAMG: Solving for p, Initial residual = 0.000389416, Final residual = 7.09834e-07, No Iterations 15
time step continuity errors : sum local = 1.8957e-10, global = 8.09819e-12, cumulative = 4.44025e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000997351, Final residual = 2.31646e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176603, Final residual = 2.76547e-06, No Iterations 4
ExecutionTime = 17.89 s ClockTime = 18 s
Time = 1.77
Courant Number mean: 0.127353 max: 0.61681
smoothSolver: Solving for Ux, Initial residual = 0.000857738, Final residual = 1.85048e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00205885, Final residual = 7.68978e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00235503, Final residual = 0.000196967, No Iterations 4
time step continuity errors : sum local = 5.26013e-08, global = 4.28067e-11, cumulative = 4.44029e-06
GAMG: Solving for p, Initial residual = 0.000387967, Final residual = 6.7066e-07, No Iterations 15
time step continuity errors : sum local = 1.79156e-10, global = 7.60153e-12, cumulative = 4.4403e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00099881, Final residual = 2.33288e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176572, Final residual = 2.79192e-06, No Iterations 4
ExecutionTime = 17.92 s ClockTime = 18 s
Time = 1.7725
Courant Number mean: 0.127392 max: 0.61681
smoothSolver: Solving for Ux, Initial residual = 0.000857286, Final residual = 1.85542e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00206071, Final residual = 7.71055e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00239356, Final residual = 0.000193819, No Iterations 4
time step continuity errors : sum local = 5.17666e-08, global = -2.21279e-10, cumulative = 4.44008e-06
GAMG: Solving for p, Initial residual = 0.000393299, Final residual = 7.81969e-07, No Iterations 15
time step continuity errors : sum local = 2.08886e-10, global = 9.29226e-12, cumulative = 4.44009e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100027, Final residual = 2.34652e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176534, Final residual = 2.8165e-06, No Iterations 4
ExecutionTime = 17.94 s ClockTime = 18 s
Time = 1.775
Courant Number mean: 0.127431 max: 0.616809
smoothSolver: Solving for Ux, Initial residual = 0.000856755, Final residual = 1.85964e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00206282, Final residual = 7.73412e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00242559, Final residual = 0.00019573, No Iterations 4
time step continuity errors : sum local = 5.22782e-08, global = -1.02495e-10, cumulative = 4.43998e-06
GAMG: Solving for p, Initial residual = 0.000399505, Final residual = 7.31863e-07, No Iterations 15
time step continuity errors : sum local = 1.95509e-10, global = 8.4711e-12, cumulative = 4.43999e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100166, Final residual = 2.3609e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176495, Final residual = 2.8423e-06, No Iterations 4
ExecutionTime = 17.96 s ClockTime = 18 s
Time = 1.7775
Courant Number mean: 0.127469 max: 0.616808
smoothSolver: Solving for Ux, Initial residual = 0.000856251, Final residual = 1.86388e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00206466, Final residual = 7.75651e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00245103, Final residual = 0.000196405, No Iterations 4
time step continuity errors : sum local = 5.24579e-08, global = -1.96574e-10, cumulative = 4.4398e-06
GAMG: Solving for p, Initial residual = 0.00039825, Final residual = 7.56611e-07, No Iterations 15
time step continuity errors : sum local = 2.02111e-10, global = 8.91149e-12, cumulative = 4.4398e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100323, Final residual = 2.38957e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176459, Final residual = 2.86262e-06, No Iterations 4
ExecutionTime = 17.98 s ClockTime = 18 s
Time = 1.78
Courant Number mean: 0.127507 max: 0.616807
smoothSolver: Solving for Ux, Initial residual = 0.000855806, Final residual = 1.86873e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00206602, Final residual = 7.77828e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00246007, Final residual = 0.000195798, No Iterations 4
time step continuity errors : sum local = 5.22919e-08, global = -2.28873e-10, cumulative = 4.43958e-06
GAMG: Solving for p, Initial residual = 0.000398478, Final residual = 7.6338e-07, No Iterations 15
time step continuity errors : sum local = 2.03899e-10, global = 8.99569e-12, cumulative = 4.43958e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100484, Final residual = 2.40132e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176434, Final residual = 2.88339e-06, No Iterations 4
ExecutionTime = 18 s ClockTime = 18 s
Time = 1.7825
Courant Number mean: 0.127545 max: 0.616807
smoothSolver: Solving for Ux, Initial residual = 0.000855342, Final residual = 1.87325e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00206736, Final residual = 7.80044e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00250804, Final residual = 0.00019584, No Iterations 4
time step continuity errors : sum local = 5.22982e-08, global = -1.50155e-10, cumulative = 4.43943e-06
GAMG: Solving for p, Initial residual = 0.000402777, Final residual = 7.42204e-07, No Iterations 15
time step continuity errors : sum local = 1.98222e-10, global = 8.63965e-12, cumulative = 4.43944e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100643, Final residual = 2.42317e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176405, Final residual = 2.90384e-06, No Iterations 4
ExecutionTime = 18.03 s ClockTime = 18 s
Time = 1.785
Courant Number mean: 0.127582 max: 0.616806
smoothSolver: Solving for Ux, Initial residual = 0.000854922, Final residual = 1.87802e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00206856, Final residual = 7.82267e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00261969, Final residual = 0.00019758, No Iterations 4
time step continuity errors : sum local = 5.27613e-08, global = -2.82057e-10, cumulative = 4.43916e-06
GAMG: Solving for p, Initial residual = 0.000411155, Final residual = 7.74152e-07, No Iterations 15
time step continuity errors : sum local = 2.06766e-10, global = 9.14451e-12, cumulative = 4.43917e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100803, Final residual = 2.43489e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176381, Final residual = 2.92689e-06, No Iterations 4
ExecutionTime = 18.05 s ClockTime = 18 s
Time = 1.7875
Courant Number mean: 0.127619 max: 0.616805
smoothSolver: Solving for Ux, Initial residual = 0.000854546, Final residual = 1.88349e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00206947, Final residual = 7.84572e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00264559, Final residual = 0.00019739, No Iterations 4
time step continuity errors : sum local = 5.27116e-08, global = -2.51496e-10, cumulative = 4.43892e-06
GAMG: Solving for p, Initial residual = 0.000409923, Final residual = 7.91584e-07, No Iterations 15
time step continuity errors : sum local = 2.11418e-10, global = 9.50733e-12, cumulative = 4.43893e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100961, Final residual = 2.44881e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017637, Final residual = 2.95134e-06, No Iterations 4
ExecutionTime = 18.07 s ClockTime = 18 s
Time = 1.79
Courant Number mean: 0.127656 max: 0.616804
smoothSolver: Solving for Ux, Initial residual = 0.000854047, Final residual = 1.88825e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00207058, Final residual = 7.87042e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00260399, Final residual = 0.000194652, No Iterations 4
time step continuity errors : sum local = 5.19772e-08, global = -3.3778e-10, cumulative = 4.43859e-06
GAMG: Solving for p, Initial residual = 0.000406418, Final residual = 7.92553e-07, No Iterations 15
time step continuity errors : sum local = 2.11656e-10, global = 9.49829e-12, cumulative = 4.4386e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010112, Final residual = 2.46532e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176352, Final residual = 2.9691e-06, No Iterations 4
ExecutionTime = 18.09 s ClockTime = 18 s
Time = 1.7925
Courant Number mean: 0.127693 max: 0.616804
smoothSolver: Solving for Ux, Initial residual = 0.000853592, Final residual = 1.89351e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0020717, Final residual = 7.89384e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00246045, Final residual = 0.00019656, No Iterations 4
time step continuity errors : sum local = 5.2486e-08, global = -3.62397e-10, cumulative = 4.43824e-06
GAMG: Solving for p, Initial residual = 0.000400983, Final residual = 7.90123e-07, No Iterations 15
time step continuity errors : sum local = 2.11025e-10, global = 9.42866e-12, cumulative = 4.43825e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101273, Final residual = 2.48153e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176335, Final residual = 2.98775e-06, No Iterations 4
ExecutionTime = 18.12 s ClockTime = 18 s
Time = 1.795
Courant Number mean: 0.127729 max: 0.616803
smoothSolver: Solving for Ux, Initial residual = 0.000853101, Final residual = 1.89879e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00207279, Final residual = 7.91754e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00249797, Final residual = 0.000195673, No Iterations 4
time step continuity errors : sum local = 5.22541e-08, global = -3.93119e-10, cumulative = 4.43785e-06
GAMG: Solving for p, Initial residual = 0.000407645, Final residual = 8.06781e-07, No Iterations 15
time step continuity errors : sum local = 2.15495e-10, global = 9.71594e-12, cumulative = 4.43786e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101417, Final residual = 2.49545e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176315, Final residual = 3.00907e-06, No Iterations 4
ExecutionTime = 18.15 s ClockTime = 18 s
Time = 1.7975
Courant Number mean: 0.127765 max: 0.616802
smoothSolver: Solving for Ux, Initial residual = 0.000852745, Final residual = 1.90427e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00207367, Final residual = 7.94258e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00252357, Final residual = 0.000197851, No Iterations 4
time step continuity errors : sum local = 5.28461e-08, global = -6.96657e-10, cumulative = 4.43717e-06
GAMG: Solving for p, Initial residual = 0.000406218, Final residual = 8.912e-07, No Iterations 15
time step continuity errors : sum local = 2.38095e-10, global = 1.12364e-11, cumulative = 4.43718e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101539, Final residual = 2.51594e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176292, Final residual = 3.02599e-06, No Iterations 4
ExecutionTime = 18.17 s ClockTime = 18 s
Time = 1.8
Courant Number mean: 0.127801 max: 0.616802
smoothSolver: Solving for Ux, Initial residual = 0.000852291, Final residual = 1.91033e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00207464, Final residual = 7.96654e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00244193, Final residual = 0.000193962, No Iterations 4
time step continuity errors : sum local = 5.18144e-08, global = -4.13721e-10, cumulative = 4.43676e-06
GAMG: Solving for p, Initial residual = 0.00040191, Final residual = 7.99424e-07, No Iterations 15
time step continuity errors : sum local = 2.13601e-10, global = 9.49184e-12, cumulative = 4.43677e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101644, Final residual = 2.52956e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176267, Final residual = 3.04207e-06, No Iterations 4
ExecutionTime = 18.22 s ClockTime = 18 s
Time = 1.8025
Courant Number mean: 0.127836 max: 0.616801
smoothSolver: Solving for Ux, Initial residual = 0.000851829, Final residual = 1.91429e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00207612, Final residual = 7.99114e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00247853, Final residual = 0.00019558, No Iterations 4
time step continuity errors : sum local = 5.22551e-08, global = -4.35442e-10, cumulative = 4.43634e-06
GAMG: Solving for p, Initial residual = 0.000402258, Final residual = 8.23281e-07, No Iterations 15
time step continuity errors : sum local = 2.20024e-10, global = 1.00322e-11, cumulative = 4.43635e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101738, Final residual = 2.54443e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176241, Final residual = 3.06162e-06, No Iterations 4
ExecutionTime = 18.24 s ClockTime = 18 s
Time = 1.805
Courant Number mean: 0.127871 max: 0.6168
smoothSolver: Solving for Ux, Initial residual = 0.000851461, Final residual = 1.92077e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00207777, Final residual = 8.01715e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00254053, Final residual = 0.00019747, No Iterations 4
time step continuity errors : sum local = 5.27699e-08, global = -9.80256e-10, cumulative = 4.43537e-06
GAMG: Solving for p, Initial residual = 0.000404395, Final residual = 9.59044e-07, No Iterations 15
time step continuity errors : sum local = 2.56322e-10, global = 1.23944e-11, cumulative = 4.43538e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101838, Final residual = 2.56597e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176212, Final residual = 3.07688e-06, No Iterations 4
ExecutionTime = 18.26 s ClockTime = 18 s
Time = 1.8075
Courant Number mean: 0.127906 max: 0.6168
smoothSolver: Solving for Ux, Initial residual = 0.000851004, Final residual = 1.92589e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00207992, Final residual = 8.04245e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00239498, Final residual = 0.000197436, No Iterations 4
time step continuity errors : sum local = 5.27645e-08, global = -7.83127e-10, cumulative = 4.4346e-06
GAMG: Solving for p, Initial residual = 0.000396028, Final residual = 9.33155e-07, No Iterations 15
time step continuity errors : sum local = 2.49423e-10, global = 1.19536e-11, cumulative = 4.43461e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101953, Final residual = 2.58449e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176197, Final residual = 3.09781e-06, No Iterations 4
ExecutionTime = 18.29 s ClockTime = 18 s
Time = 1.81
Courant Number mean: 0.127942 max: 0.616799
smoothSolver: Solving for Ux, Initial residual = 0.000850508, Final residual = 1.93094e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00208226, Final residual = 8.06792e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00244811, Final residual = 0.000197937, No Iterations 4
time step continuity errors : sum local = 5.29056e-08, global = -8.43545e-10, cumulative = 4.43377e-06
GAMG: Solving for p, Initial residual = 0.00039928, Final residual = 9.63372e-07, No Iterations 15
time step continuity errors : sum local = 2.57543e-10, global = 1.25379e-11, cumulative = 4.43378e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102071, Final residual = 2.60779e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176178, Final residual = 3.11226e-06, No Iterations 4
ExecutionTime = 18.31 s ClockTime = 18 s
Time = 1.8125
Courant Number mean: 0.127978 max: 0.616798
smoothSolver: Solving for Ux, Initial residual = 0.000850008, Final residual = 1.93641e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0020845, Final residual = 8.09363e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00238242, Final residual = 0.000198556, No Iterations 4
time step continuity errors : sum local = 5.30802e-08, global = -8.66612e-10, cumulative = 4.43291e-06
GAMG: Solving for p, Initial residual = 0.000398071, Final residual = 9.47459e-07, No Iterations 15
time step continuity errors : sum local = 2.53324e-10, global = 1.21994e-11, cumulative = 4.43292e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102195, Final residual = 2.61953e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176154, Final residual = 3.12651e-06, No Iterations 4
ExecutionTime = 18.33 s ClockTime = 18 s
Time = 1.815
Courant Number mean: 0.128015 max: 0.616797
smoothSolver: Solving for Ux, Initial residual = 0.000849569, Final residual = 1.94181e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0020866, Final residual = 8.11741e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00242145, Final residual = 0.000196906, No Iterations 4
time step continuity errors : sum local = 5.26433e-08, global = -5.09666e-10, cumulative = 4.43241e-06
GAMG: Solving for p, Initial residual = 0.000404162, Final residual = 8.40494e-07, No Iterations 15
time step continuity errors : sum local = 2.24751e-10, global = 1.02064e-11, cumulative = 4.43242e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102349, Final residual = 2.63963e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176134, Final residual = 3.1393e-06, No Iterations 4
ExecutionTime = 18.35 s ClockTime = 18 s
Time = 1.8175
Courant Number mean: 0.128052 max: 0.616797
smoothSolver: Solving for Ux, Initial residual = 0.000849116, Final residual = 1.9463e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00208884, Final residual = 8.14138e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00250061, Final residual = 0.000197056, No Iterations 4
time step continuity errors : sum local = 5.26863e-08, global = -5.62562e-10, cumulative = 4.43186e-06
GAMG: Solving for p, Initial residual = 0.00040813, Final residual = 8.58503e-07, No Iterations 15
time step continuity errors : sum local = 2.29573e-10, global = 1.05836e-11, cumulative = 4.43187e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102504, Final residual = 2.65309e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176119, Final residual = 3.15144e-06, No Iterations 4
ExecutionTime = 18.37 s ClockTime = 18 s
Time = 1.82
Courant Number mean: 0.128089 max: 0.616796
smoothSolver: Solving for Ux, Initial residual = 0.00084866, Final residual = 1.95253e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00209088, Final residual = 8.16589e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00248698, Final residual = 0.000198108, No Iterations 4
time step continuity errors : sum local = 5.29687e-08, global = -7.40824e-10, cumulative = 4.43113e-06
GAMG: Solving for p, Initial residual = 0.000407837, Final residual = 8.60354e-07, No Iterations 15
time step continuity errors : sum local = 2.30077e-10, global = 1.04597e-11, cumulative = 4.43114e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102646, Final residual = 2.67033e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176103, Final residual = 3.1649e-06, No Iterations 4
ExecutionTime = 18.4 s ClockTime = 19 s
Time = 1.8225
Courant Number mean: 0.128125 max: 0.616795
smoothSolver: Solving for Ux, Initial residual = 0.00084819, Final residual = 1.95772e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00209308, Final residual = 8.19037e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00252573, Final residual = 0.000198036, No Iterations 4
time step continuity errors : sum local = 5.29486e-08, global = -6.6669e-10, cumulative = 4.43048e-06
GAMG: Solving for p, Initial residual = 0.000409025, Final residual = 8.63958e-07, No Iterations 15
time step continuity errors : sum local = 2.31024e-10, global = 1.06009e-11, cumulative = 4.43049e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102787, Final residual = 2.68439e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176073, Final residual = 3.1799e-06, No Iterations 4
ExecutionTime = 18.41 s ClockTime = 19 s
Time = 1.825
Courant Number mean: 0.128162 max: 0.616795
smoothSolver: Solving for Ux, Initial residual = 0.000847761, Final residual = 1.96397e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00209534, Final residual = 8.21555e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00256664, Final residual = 0.000197102, No Iterations 4
time step continuity errors : sum local = 5.26973e-08, global = -8.74225e-10, cumulative = 4.42961e-06
GAMG: Solving for p, Initial residual = 0.000417605, Final residual = 8.7145e-07, No Iterations 15
time step continuity errors : sum local = 2.33033e-10, global = 1.06116e-11, cumulative = 4.42962e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102926, Final residual = 2.70014e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176038, Final residual = 3.19137e-06, No Iterations 4
ExecutionTime = 18.43 s ClockTime = 19 s
Time = 1.8275
Courant Number mean: 0.128199 max: 0.616794
smoothSolver: Solving for Ux, Initial residual = 0.000847327, Final residual = 1.96977e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00209777, Final residual = 8.24054e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00266443, Final residual = 0.000206491, No Iterations 4
time step continuity errors : sum local = 5.52088e-08, global = -6.00334e-10, cumulative = 4.42902e-06
GAMG: Solving for p, Initial residual = 0.000421443, Final residual = 8.28563e-07, No Iterations 15
time step continuity errors : sum local = 2.2157e-10, global = 1.00179e-11, cumulative = 4.42903e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103063, Final residual = 2.71544e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176005, Final residual = 3.2067e-06, No Iterations 4
ExecutionTime = 18.46 s ClockTime = 19 s
Time = 1.83
Courant Number mean: 0.128237 max: 0.616794
smoothSolver: Solving for Ux, Initial residual = 0.000846876, Final residual = 1.97607e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00209965, Final residual = 8.26546e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00276177, Final residual = 0.000204396, No Iterations 4
time step continuity errors : sum local = 5.46512e-08, global = -8.1975e-10, cumulative = 4.42821e-06
GAMG: Solving for p, Initial residual = 0.000429249, Final residual = 8.33672e-07, No Iterations 15
time step continuity errors : sum local = 2.22953e-10, global = 1.00512e-11, cumulative = 4.42822e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103198, Final residual = 2.739e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175982, Final residual = 3.21661e-06, No Iterations 4
ExecutionTime = 18.47 s ClockTime = 19 s
Time = 1.8325
Courant Number mean: 0.128274 max: 0.616793
smoothSolver: Solving for Ux, Initial residual = 0.000846494, Final residual = 1.98211e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00210126, Final residual = 8.28966e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00271671, Final residual = 0.000205217, No Iterations 4
time step continuity errors : sum local = 5.48656e-08, global = -1.06905e-09, cumulative = 4.42715e-06
GAMG: Solving for p, Initial residual = 0.000432139, Final residual = 9.83973e-07, No Iterations 15
time step continuity errors : sum local = 2.63082e-10, global = 1.26577e-11, cumulative = 4.42717e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103337, Final residual = 2.75323e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175971, Final residual = 3.22704e-06, No Iterations 4
ExecutionTime = 18.5 s ClockTime = 19 s
Time = 1.835
Courant Number mean: 0.128311 max: 0.616792
smoothSolver: Solving for Ux, Initial residual = 0.000846004, Final residual = 1.98843e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0021031, Final residual = 8.31622e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00261993, Final residual = 0.000202428, No Iterations 4
time step continuity errors : sum local = 5.41138e-08, global = -9.63966e-10, cumulative = 4.4262e-06
GAMG: Solving for p, Initial residual = 0.000421943, Final residual = 9.05582e-07, No Iterations 15
time step continuity errors : sum local = 2.42119e-10, global = 1.12389e-11, cumulative = 4.42621e-06
smoothSolver: Solving for epsilon, Initial residual = 0.001035, Final residual = 2.77599e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175953, Final residual = 3.23819e-06, No Iterations 4
ExecutionTime = 18.52 s ClockTime = 19 s
Time = 1.8375
Courant Number mean: 0.128348 max: 0.616792
smoothSolver: Solving for Ux, Initial residual = 0.000845593, Final residual = 1.99387e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00210445, Final residual = 8.34038e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00263155, Final residual = 0.00020901, No Iterations 4
time step continuity errors : sum local = 5.58688e-08, global = -8.58434e-10, cumulative = 4.42536e-06
GAMG: Solving for p, Initial residual = 0.000428368, Final residual = 8.88571e-07, No Iterations 15
time step continuity errors : sum local = 2.37545e-10, global = 1.09746e-11, cumulative = 4.42537e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010366, Final residual = 2.78998e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017594, Final residual = 3.246e-06, No Iterations 4
ExecutionTime = 18.54 s ClockTime = 19 s
Time = 1.84
Courant Number mean: 0.128384 max: 0.616791
smoothSolver: Solving for Ux, Initial residual = 0.00084525, Final residual = 2.00088e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00210551, Final residual = 8.36464e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00252113, Final residual = 0.000205757, No Iterations 4
time step continuity errors : sum local = 5.49943e-08, global = -1.10171e-09, cumulative = 4.42426e-06
GAMG: Solving for p, Initial residual = 0.000421197, Final residual = 9.42413e-07, No Iterations 15
time step continuity errors : sum local = 2.51924e-10, global = 1.18217e-11, cumulative = 4.42428e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103816, Final residual = 2.80399e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175926, Final residual = 3.25873e-06, No Iterations 4
ExecutionTime = 18.56 s ClockTime = 19 s
Time = 1.8425
Courant Number mean: 0.12842 max: 0.61679
smoothSolver: Solving for Ux, Initial residual = 0.000844918, Final residual = 2.00728e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00210655, Final residual = 8.38959e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00251877, Final residual = 0.000205464, No Iterations 4
time step continuity errors : sum local = 5.49184e-08, global = -1.03833e-09, cumulative = 4.42324e-06
GAMG: Solving for p, Initial residual = 0.000424302, Final residual = 9.43495e-07, No Iterations 15
time step continuity errors : sum local = 2.52241e-10, global = 1.18838e-11, cumulative = 4.42325e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103974, Final residual = 2.83046e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175911, Final residual = 3.26678e-06, No Iterations 4
ExecutionTime = 18.59 s ClockTime = 19 s
Time = 1.845
Courant Number mean: 0.128456 max: 0.61679
smoothSolver: Solving for Ux, Initial residual = 0.000844519, Final residual = 2.0138e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00210754, Final residual = 8.41483e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0024864, Final residual = 0.000206007, No Iterations 4
time step continuity errors : sum local = 5.50727e-08, global = -1.03635e-09, cumulative = 4.42221e-06
GAMG: Solving for p, Initial residual = 0.000420635, Final residual = 9.56779e-07, No Iterations 15
time step continuity errors : sum local = 2.55853e-10, global = 1.21431e-11, cumulative = 4.42223e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104118, Final residual = 2.84427e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175898, Final residual = 3.27657e-06, No Iterations 4
ExecutionTime = 18.61 s ClockTime = 19 s
Time = 1.8475
Courant Number mean: 0.128492 max: 0.616789
smoothSolver: Solving for Ux, Initial residual = 0.000844057, Final residual = 2.0205e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00210857, Final residual = 8.43987e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00251507, Final residual = 0.000205494, No Iterations 4
time step continuity errors : sum local = 5.49433e-08, global = -1.03946e-09, cumulative = 4.42119e-06
GAMG: Solving for p, Initial residual = 0.000418626, Final residual = 9.67759e-07, No Iterations 15
time step continuity errors : sum local = 2.58805e-10, global = 1.23741e-11, cumulative = 4.4212e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104276, Final residual = 2.85744e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175879, Final residual = 3.287e-06, No Iterations 4
ExecutionTime = 18.63 s ClockTime = 19 s
Time = 1.85
Courant Number mean: 0.128528 max: 0.616788
smoothSolver: Solving for Ux, Initial residual = 0.000843643, Final residual = 2.02733e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0021099, Final residual = 8.46519e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00262587, Final residual = 0.00020778, No Iterations 4
time step continuity errors : sum local = 5.55651e-08, global = -9.68691e-10, cumulative = 4.42023e-06
GAMG: Solving for p, Initial residual = 0.000429657, Final residual = 9.32473e-07, No Iterations 15
time step continuity errors : sum local = 2.49443e-10, global = 1.17371e-11, cumulative = 4.42024e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104421, Final residual = 2.87152e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175859, Final residual = 3.30842e-06, No Iterations 4
ExecutionTime = 18.65 s ClockTime = 19 s
Time = 1.8525
Courant Number mean: 0.128563 max: 0.616788
smoothSolver: Solving for Ux, Initial residual = 0.000843298, Final residual = 2.03414e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00211113, Final residual = 8.4912e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00263443, Final residual = 0.000205852, No Iterations 4
time step continuity errors : sum local = 5.50543e-08, global = -1.00686e-09, cumulative = 4.41923e-06
GAMG: Solving for p, Initial residual = 0.00043227, Final residual = 9.89215e-07, No Iterations 15
time step continuity errors : sum local = 2.64588e-10, global = 1.28721e-11, cumulative = 4.41925e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104565, Final residual = 2.88676e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175834, Final residual = 3.32124e-06, No Iterations 4
ExecutionTime = 18.68 s ClockTime = 19 s
Time = 1.855
Courant Number mean: 0.128599 max: 0.616787
smoothSolver: Solving for Ux, Initial residual = 0.000842829, Final residual = 2.04088e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00211286, Final residual = 8.51749e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0025028, Final residual = 0.000206276, No Iterations 4
time step continuity errors : sum local = 5.51673e-08, global = -9.75441e-10, cumulative = 4.41827e-06
GAMG: Solving for p, Initial residual = 0.000424829, Final residual = 9.57226e-07, No Iterations 15
time step continuity errors : sum local = 2.56065e-10, global = 1.2253e-11, cumulative = 4.41828e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104721, Final residual = 2.90346e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175813, Final residual = 3.33254e-06, No Iterations 4
ExecutionTime = 18.7 s ClockTime = 19 s
Time = 1.8575
Courant Number mean: 0.128633 max: 0.616787
smoothSolver: Solving for Ux, Initial residual = 0.000842355, Final residual = 2.04725e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0021147, Final residual = 8.54329e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00254562, Final residual = 0.000208901, No Iterations 4
time step continuity errors : sum local = 5.5879e-08, global = -9.85426e-10, cumulative = 4.4173e-06
GAMG: Solving for p, Initial residual = 0.000425162, Final residual = 9.71613e-07, No Iterations 15
time step continuity errors : sum local = 2.59972e-10, global = 1.25422e-11, cumulative = 4.41731e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104895, Final residual = 2.91954e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017581, Final residual = 3.34566e-06, No Iterations 4
ExecutionTime = 18.72 s ClockTime = 19 s
Time = 1.86
Courant Number mean: 0.128668 max: 0.616786
smoothSolver: Solving for Ux, Initial residual = 0.000841839, Final residual = 2.05404e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00211655, Final residual = 8.57108e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00255234, Final residual = 0.00020805, No Iterations 4
time step continuity errors : sum local = 5.5664e-08, global = -1.03591e-09, cumulative = 4.41628e-06
GAMG: Solving for p, Initial residual = 0.000426402, Final residual = 9.9718e-07, No Iterations 15
time step continuity errors : sum local = 2.66854e-10, global = 1.30109e-11, cumulative = 4.41629e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105056, Final residual = 2.94361e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175816, Final residual = 3.36014e-06, No Iterations 4
ExecutionTime = 18.74 s ClockTime = 19 s
Time = 1.8625
Courant Number mean: 0.128702 max: 0.616785
smoothSolver: Solving for Ux, Initial residual = 0.000841319, Final residual = 2.0608e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00211849, Final residual = 8.59836e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00253676, Final residual = 0.000209325, No Iterations 4
time step continuity errors : sum local = 5.60093e-08, global = -9.40917e-10, cumulative = 4.41535e-06
GAMG: Solving for p, Initial residual = 0.000428318, Final residual = 9.56978e-07, No Iterations 15
time step continuity errors : sum local = 2.56111e-10, global = 1.23262e-11, cumulative = 4.41536e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105203, Final residual = 2.96296e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175823, Final residual = 3.37504e-06, No Iterations 4
ExecutionTime = 18.77 s ClockTime = 19 s
Time = 1.865
Courant Number mean: 0.128736 max: 0.616785
smoothSolver: Solving for Ux, Initial residual = 0.00084085, Final residual = 2.06675e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00212041, Final residual = 8.62555e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00254978, Final residual = 0.000212393, No Iterations 4
time step continuity errors : sum local = 5.68335e-08, global = -9.75572e-10, cumulative = 4.41438e-06
GAMG: Solving for p, Initial residual = 0.000433122, Final residual = 9.51596e-07, No Iterations 15
time step continuity errors : sum local = 2.54666e-10, global = 1.22496e-11, cumulative = 4.4144e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105335, Final residual = 2.97742e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175836, Final residual = 3.39092e-06, No Iterations 4
ExecutionTime = 18.79 s ClockTime = 19 s
Time = 1.8675
Courant Number mean: 0.12877 max: 0.616784
smoothSolver: Solving for Ux, Initial residual = 0.000840403, Final residual = 2.07365e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00212237, Final residual = 8.65298e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00255366, Final residual = 0.000210151, No Iterations 4
time step continuity errors : sum local = 5.62379e-08, global = -7.52927e-10, cumulative = 4.41364e-06
GAMG: Solving for p, Initial residual = 0.000430712, Final residual = 5.35782e-07, No Iterations 17
time step continuity errors : sum local = 1.43406e-10, global = 7.29874e-12, cumulative = 4.41365e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105456, Final residual = 2.99146e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175851, Final residual = 3.40755e-06, No Iterations 4
ExecutionTime = 18.81 s ClockTime = 19 s
Time = 1.87
Courant Number mean: 0.128804 max: 0.616784
smoothSolver: Solving for Ux, Initial residual = 0.000839918, Final residual = 2.08082e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00212441, Final residual = 8.68145e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00249305, Final residual = 0.000212021, No Iterations 4
time step continuity errors : sum local = 5.67441e-08, global = -9.5301e-10, cumulative = 4.4127e-06
GAMG: Solving for p, Initial residual = 0.000424695, Final residual = 9.91408e-07, No Iterations 15
time step continuity errors : sum local = 2.6539e-10, global = 1.30451e-11, cumulative = 4.41271e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010556, Final residual = 3.00597e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175868, Final residual = 3.43207e-06, No Iterations 4
ExecutionTime = 18.83 s ClockTime = 19 s
Time = 1.8725
Courant Number mean: 0.128837 max: 0.616783
smoothSolver: Solving for Ux, Initial residual = 0.000839466, Final residual = 2.08778e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00212646, Final residual = 8.7089e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00256186, Final residual = 0.000212354, No Iterations 4
time step continuity errors : sum local = 5.68358e-08, global = -7.90208e-10, cumulative = 4.41192e-06
GAMG: Solving for p, Initial residual = 0.00042989, Final residual = 9.82887e-07, No Iterations 15
time step continuity errors : sum local = 2.63111e-10, global = 1.29715e-11, cumulative = 4.41193e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105666, Final residual = 3.02946e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175871, Final residual = 3.44837e-06, No Iterations 4
ExecutionTime = 18.86 s ClockTime = 19 s
Time = 1.875
Courant Number mean: 0.128871 max: 0.616782
smoothSolver: Solving for Ux, Initial residual = 0.00083902, Final residual = 2.09489e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00212852, Final residual = 8.73584e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00269274, Final residual = 0.000211225, No Iterations 4
time step continuity errors : sum local = 5.65335e-08, global = -8.82325e-10, cumulative = 4.41105e-06
GAMG: Solving for p, Initial residual = 0.000443956, Final residual = 5.19853e-07, No Iterations 17
time step continuity errors : sum local = 1.3916e-10, global = 6.95049e-12, cumulative = 4.41106e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010578, Final residual = 3.04545e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175857, Final residual = 3.46931e-06, No Iterations 4
ExecutionTime = 18.88 s ClockTime = 19 s
Time = 1.8775
Courant Number mean: 0.128903 max: 0.616782
smoothSolver: Solving for Ux, Initial residual = 0.000838618, Final residual = 2.10179e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00213063, Final residual = 8.76258e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0026508, Final residual = 0.000208187, No Iterations 4
time step continuity errors : sum local = 5.57206e-08, global = -8.73506e-10, cumulative = 4.41018e-06
GAMG: Solving for p, Initial residual = 0.000439113, Final residual = 5.15072e-07, No Iterations 17
time step continuity errors : sum local = 1.37882e-10, global = 6.84165e-12, cumulative = 4.41019e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105899, Final residual = 3.05847e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175855, Final residual = 3.48785e-06, No Iterations 4
ExecutionTime = 18.9 s ClockTime = 19 s
Time = 1.88
Courant Number mean: 0.128935 max: 0.616781
smoothSolver: Solving for Ux, Initial residual = 0.000838318, Final residual = 2.10895e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00213269, Final residual = 8.78887e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00266604, Final residual = 0.000216534, No Iterations 4
time step continuity errors : sum local = 5.79545e-08, global = -9.41408e-10, cumulative = 4.40925e-06
GAMG: Solving for p, Initial residual = 0.00044645, Final residual = 5.61421e-07, No Iterations 17
time step continuity errors : sum local = 1.50288e-10, global = 7.76085e-12, cumulative = 4.40926e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010602, Final residual = 3.07833e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175857, Final residual = 3.50554e-06, No Iterations 4
ExecutionTime = 18.93 s ClockTime = 19 s
Time = 1.8825
Courant Number mean: 0.128967 max: 0.616781
smoothSolver: Solving for Ux, Initial residual = 0.000837989, Final residual = 2.11607e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0021349, Final residual = 8.81716e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00273816, Final residual = 0.000208777, No Iterations 4
time step continuity errors : sum local = 5.58801e-08, global = -7.56662e-10, cumulative = 4.4085e-06
GAMG: Solving for p, Initial residual = 0.000442606, Final residual = 9.94738e-07, No Iterations 15
time step continuity errors : sum local = 2.66301e-10, global = 1.32315e-11, cumulative = 4.40851e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106147, Final residual = 3.092e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175863, Final residual = 3.52494e-06, No Iterations 4
ExecutionTime = 18.96 s ClockTime = 19 s
Time = 1.885
Courant Number mean: 0.128999 max: 0.61678
smoothSolver: Solving for Ux, Initial residual = 0.000837709, Final residual = 2.12301e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00213677, Final residual = 8.84438e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00270047, Final residual = 0.000208471, No Iterations 4
time step continuity errors : sum local = 5.58013e-08, global = -7.44736e-10, cumulative = 4.40777e-06
GAMG: Solving for p, Initial residual = 0.000440832, Final residual = 5.22395e-07, No Iterations 17
time step continuity errors : sum local = 1.39857e-10, global = 7.08234e-12, cumulative = 4.40778e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010629, Final residual = 3.10608e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175876, Final residual = 3.54421e-06, No Iterations 4
ExecutionTime = 18.98 s ClockTime = 19 s
Time = 1.8875
Courant Number mean: 0.129031 max: 0.61678
smoothSolver: Solving for Ux, Initial residual = 0.000837409, Final residual = 2.13045e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00213859, Final residual = 8.8724e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00268248, Final residual = 0.000209455, No Iterations 4
time step continuity errors : sum local = 5.60685e-08, global = -7.02538e-10, cumulative = 4.40707e-06
GAMG: Solving for p, Initial residual = 0.000441488, Final residual = 5.10481e-07, No Iterations 17
time step continuity errors : sum local = 1.36679e-10, global = 6.90031e-12, cumulative = 4.40708e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106454, Final residual = 3.12751e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175895, Final residual = 3.57235e-06, No Iterations 4
ExecutionTime = 19 s ClockTime = 19 s
Time = 1.89
Courant Number mean: 0.129064 max: 0.616779
smoothSolver: Solving for Ux, Initial residual = 0.000837059, Final residual = 2.13756e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00214024, Final residual = 8.90057e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00285658, Final residual = 0.000206369, No Iterations 4
time step continuity errors : sum local = 5.52421e-08, global = -5.72354e-10, cumulative = 4.40651e-06
GAMG: Solving for p, Initial residual = 0.000450632, Final residual = 9.96034e-07, No Iterations 15
time step continuity errors : sum local = 2.66663e-10, global = 1.34049e-11, cumulative = 4.40652e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106617, Final residual = 3.14123e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175918, Final residual = 3.59244e-06, No Iterations 4
ExecutionTime = 19.02 s ClockTime = 19 s
Time = 1.8925
Courant Number mean: 0.129098 max: 0.616779
smoothSolver: Solving for Ux, Initial residual = 0.000836698, Final residual = 2.14489e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00214155, Final residual = 8.92803e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00292417, Final residual = 0.000206312, No Iterations 4
time step continuity errors : sum local = 5.52224e-08, global = -4.04352e-10, cumulative = 4.40612e-06
GAMG: Solving for p, Initial residual = 0.000452745, Final residual = 9.2764e-07, No Iterations 15
time step continuity errors : sum local = 2.48333e-10, global = 1.23537e-11, cumulative = 4.40613e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106745, Final residual = 3.15486e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175931, Final residual = 3.61477e-06, No Iterations 4
ExecutionTime = 19.04 s ClockTime = 19 s
Time = 1.895
Courant Number mean: 0.129131 max: 0.616778
smoothSolver: Solving for Ux, Initial residual = 0.000836286, Final residual = 2.15254e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00214282, Final residual = 8.95454e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00282929, Final residual = 0.000208006, No Iterations 4
time step continuity errors : sum local = 5.56723e-08, global = -7.4402e-10, cumulative = 4.40539e-06
GAMG: Solving for p, Initial residual = 0.000450004, Final residual = 5.5903e-07, No Iterations 17
time step continuity errors : sum local = 1.49652e-10, global = 7.88561e-12, cumulative = 4.40539e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106862, Final residual = 3.16889e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175953, Final residual = 3.63714e-06, No Iterations 4
ExecutionTime = 19.07 s ClockTime = 19 s
Time = 1.8975
Courant Number mean: 0.129166 max: 0.616778
smoothSolver: Solving for Ux, Initial residual = 0.000835842, Final residual = 2.16005e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00214416, Final residual = 8.98283e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00276791, Final residual = 0.000206562, No Iterations 4
time step continuity errors : sum local = 5.52834e-08, global = -5.17722e-10, cumulative = 4.40488e-06
GAMG: Solving for p, Initial residual = 0.000442446, Final residual = 9.89129e-07, No Iterations 15
time step continuity errors : sum local = 2.64757e-10, global = 1.34318e-11, cumulative = 4.40489e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010698, Final residual = 3.19569e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175973, Final residual = 3.66068e-06, No Iterations 4
ExecutionTime = 19.09 s ClockTime = 19 s
Time = 1.9
Courant Number mean: 0.1292 max: 0.616777
smoothSolver: Solving for Ux, Initial residual = 0.00083548, Final residual = 2.1678e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00214554, Final residual = 9.00994e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00275039, Final residual = 0.000204265, No Iterations 4
time step continuity errors : sum local = 5.46664e-08, global = -4.25189e-10, cumulative = 4.40446e-06
GAMG: Solving for p, Initial residual = 0.00044137, Final residual = 5.13697e-07, No Iterations 17
time step continuity errors : sum local = 1.37504e-10, global = 7.10469e-12, cumulative = 4.40447e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107125, Final residual = 3.20726e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175991, Final residual = 3.68464e-06, No Iterations 4
ExecutionTime = 19.15 s ClockTime = 19 s
Time = 1.9025
Courant Number mean: 0.129234 max: 0.616777
smoothSolver: Solving for Ux, Initial residual = 0.000834967, Final residual = 2.17552e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00214734, Final residual = 9.03678e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00266952, Final residual = 0.000203305, No Iterations 4
time step continuity errors : sum local = 5.44097e-08, global = -4.07847e-10, cumulative = 4.40406e-06
GAMG: Solving for p, Initial residual = 0.000434899, Final residual = 9.99624e-07, No Iterations 15
time step continuity errors : sum local = 2.67579e-10, global = 1.37311e-11, cumulative = 4.40408e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010731, Final residual = 3.21961e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176007, Final residual = 3.7088e-06, No Iterations 4
ExecutionTime = 19.17 s ClockTime = 19 s
Time = 1.905
Courant Number mean: 0.129269 max: 0.616776
smoothSolver: Solving for Ux, Initial residual = 0.000834445, Final residual = 2.18359e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00214926, Final residual = 9.06407e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00263286, Final residual = 0.000203109, No Iterations 4
time step continuity errors : sum local = 5.43554e-08, global = -3.47465e-10, cumulative = 4.40373e-06
GAMG: Solving for p, Initial residual = 0.000434737, Final residual = 5.14835e-07, No Iterations 17
time step continuity errors : sum local = 1.37799e-10, global = 7.15714e-12, cumulative = 4.40374e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107497, Final residual = 3.23425e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176009, Final residual = 3.7339e-06, No Iterations 4
ExecutionTime = 19.19 s ClockTime = 19 s
Time = 1.9075
Courant Number mean: 0.129303 max: 0.616776
smoothSolver: Solving for Ux, Initial residual = 0.000833888, Final residual = 2.19108e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00215121, Final residual = 9.09066e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00268173, Final residual = 0.000201819, No Iterations 4
time step continuity errors : sum local = 5.40081e-08, global = -2.56565e-10, cumulative = 4.40348e-06
GAMG: Solving for p, Initial residual = 0.000438494, Final residual = 5.17595e-07, No Iterations 17
time step continuity errors : sum local = 1.38538e-10, global = 7.25409e-12, cumulative = 4.40349e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107671, Final residual = 3.25513e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176009, Final residual = 3.76658e-06, No Iterations 4
ExecutionTime = 19.22 s ClockTime = 19 s
Time = 1.91
Courant Number mean: 0.129337 max: 0.616775
smoothSolver: Solving for Ux, Initial residual = 0.000833439, Final residual = 2.19946e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00215307, Final residual = 9.11888e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00269339, Final residual = 0.000198327, No Iterations 4
time step continuity errors : sum local = 5.3078e-08, global = -1.34652e-10, cumulative = 4.40335e-06
GAMG: Solving for p, Initial residual = 0.000436939, Final residual = 9.73865e-07, No Iterations 15
time step continuity errors : sum local = 2.60678e-10, global = 1.3456e-11, cumulative = 4.40337e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107839, Final residual = 3.26614e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017602, Final residual = 3.79204e-06, No Iterations 4
ExecutionTime = 19.24 s ClockTime = 19 s
Time = 1.9125
Courant Number mean: 0.129372 max: 0.616775
smoothSolver: Solving for Ux, Initial residual = 0.000832902, Final residual = 2.20718e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00215523, Final residual = 9.14578e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00264899, Final residual = 0.000198526, No Iterations 4
time step continuity errors : sum local = 5.31342e-08, global = -7.53832e-11, cumulative = 4.40329e-06
GAMG: Solving for p, Initial residual = 0.000437454, Final residual = 9.72051e-07, No Iterations 15
time step continuity errors : sum local = 2.60231e-10, global = 1.34634e-11, cumulative = 4.40331e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107993, Final residual = 3.27815e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176035, Final residual = 3.81796e-06, No Iterations 4
ExecutionTime = 19.26 s ClockTime = 19 s
Time = 1.915
Courant Number mean: 0.129406 max: 0.616774
smoothSolver: Solving for Ux, Initial residual = 0.000832409, Final residual = 2.21499e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00215724, Final residual = 9.17195e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00270308, Final residual = 0.000196001, No Iterations 4
time step continuity errors : sum local = 5.2461e-08, global = 1.44223e-10, cumulative = 4.40345e-06
GAMG: Solving for p, Initial residual = 0.000439212, Final residual = 9.11281e-07, No Iterations 15
time step continuity errors : sum local = 2.43951e-10, global = 1.25989e-11, cumulative = 4.40346e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108138, Final residual = 3.29005e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176058, Final residual = 3.84463e-06, No Iterations 4
ExecutionTime = 19.29 s ClockTime = 19 s
Time = 1.9175
Courant Number mean: 0.12944 max: 0.616774
smoothSolver: Solving for Ux, Initial residual = 0.000831871, Final residual = 2.22281e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00215937, Final residual = 9.19965e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00261452, Final residual = 0.00019529, No Iterations 4
time step continuity errors : sum local = 5.22744e-08, global = 1.56586e-10, cumulative = 4.40362e-06
GAMG: Solving for p, Initial residual = 0.000435479, Final residual = 9.00723e-07, No Iterations 15
time step continuity errors : sum local = 2.4115e-10, global = 1.24582e-11, cumulative = 4.40363e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108268, Final residual = 3.30862e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017608, Final residual = 3.87795e-06, No Iterations 4
ExecutionTime = 19.31 s ClockTime = 19 s
Time = 1.92
Courant Number mean: 0.129473 max: 0.616773
smoothSolver: Solving for Ux, Initial residual = 0.000831319, Final residual = 2.23067e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00216117, Final residual = 9.22572e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00263789, Final residual = 0.000192377, No Iterations 4
time step continuity errors : sum local = 5.14984e-08, global = 4.02165e-10, cumulative = 4.40403e-06
GAMG: Solving for p, Initial residual = 0.000438678, Final residual = 7.66408e-07, No Iterations 15
time step continuity errors : sum local = 2.05213e-10, global = 1.0572e-11, cumulative = 4.40404e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108401, Final residual = 3.32927e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176109, Final residual = 3.90811e-06, No Iterations 4
ExecutionTime = 19.34 s ClockTime = 19 s
Time = 1.9225
Courant Number mean: 0.129506 max: 0.616773
smoothSolver: Solving for Ux, Initial residual = 0.00083082, Final residual = 2.23789e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00216302, Final residual = 9.25353e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00287613, Final residual = 0.000192088, No Iterations 4
time step continuity errors : sum local = 5.14304e-08, global = 4.65797e-10, cumulative = 4.40451e-06
GAMG: Solving for p, Initial residual = 0.000454853, Final residual = 7.11225e-07, No Iterations 15
time step continuity errors : sum local = 1.90471e-10, global = 9.72337e-12, cumulative = 4.40452e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108552, Final residual = 3.33999e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176147, Final residual = 3.93823e-06, No Iterations 4
ExecutionTime = 19.36 s ClockTime = 19 s
Time = 1.925
Courant Number mean: 0.129538 max: 0.616772
smoothSolver: Solving for Ux, Initial residual = 0.000830513, Final residual = 2.24487e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0021645, Final residual = 9.28171e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00312281, Final residual = 0.000194094, No Iterations 4
time step continuity errors : sum local = 5.19751e-08, global = 8.70123e-10, cumulative = 4.40539e-06
GAMG: Solving for p, Initial residual = 0.00048058, Final residual = 6.56722e-07, No Iterations 16
time step continuity errors : sum local = 1.75887e-10, global = 9.37071e-12, cumulative = 4.4054e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108696, Final residual = 3.35164e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176174, Final residual = 3.96775e-06, No Iterations 4
ExecutionTime = 19.38 s ClockTime = 20 s
Time = 1.9275
Courant Number mean: 0.129571 max: 0.616772
smoothSolver: Solving for Ux, Initial residual = 0.000830288, Final residual = 2.2524e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00216608, Final residual = 9.30912e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00290225, Final residual = 0.000195169, No Iterations 4
time step continuity errors : sum local = 5.22621e-08, global = 8.97559e-10, cumulative = 4.4063e-06
GAMG: Solving for p, Initial residual = 0.000464897, Final residual = 7.425e-07, No Iterations 16
time step continuity errors : sum local = 1.98863e-10, global = 1.10041e-11, cumulative = 4.40631e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108823, Final residual = 3.36368e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017619, Final residual = 3.99914e-06, No Iterations 4
ExecutionTime = 19.4 s ClockTime = 20 s
Time = 1.93
Courant Number mean: 0.129603 max: 0.616772
smoothSolver: Solving for Ux, Initial residual = 0.00082999, Final residual = 2.26026e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00216795, Final residual = 9.33913e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00286324, Final residual = 0.000195388, No Iterations 4
time step continuity errors : sum local = 5.23212e-08, global = 9.55555e-10, cumulative = 4.40726e-06
GAMG: Solving for p, Initial residual = 0.000463942, Final residual = 6.93612e-07, No Iterations 16
time step continuity errors : sum local = 1.85768e-10, global = 1.00644e-11, cumulative = 4.40727e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108939, Final residual = 3.37916e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176207, Final residual = 4.03126e-06, No Iterations 4
ExecutionTime = 19.43 s ClockTime = 20 s
Time = 1.9325
Courant Number mean: 0.129635 max: 0.616771
smoothSolver: Solving for Ux, Initial residual = 0.000829699, Final residual = 2.26662e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00216954, Final residual = 9.36808e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00281969, Final residual = 0.000196621, No Iterations 4
time step continuity errors : sum local = 5.26485e-08, global = 1.18682e-09, cumulative = 4.40846e-06
GAMG: Solving for p, Initial residual = 0.000456755, Final residual = 8.20365e-07, No Iterations 16
time step continuity errors : sum local = 2.19701e-10, global = 1.22679e-11, cumulative = 4.40847e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109055, Final residual = 3.38978e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176242, Final residual = 4.06752e-06, No Iterations 4
ExecutionTime = 19.45 s ClockTime = 20 s
Time = 1.935
Courant Number mean: 0.129666 max: 0.616771
smoothSolver: Solving for Ux, Initial residual = 0.000829339, Final residual = 2.27483e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00217106, Final residual = 9.39843e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00279988, Final residual = 0.000196572, No Iterations 4
time step continuity errors : sum local = 5.26327e-08, global = 1.04015e-09, cumulative = 4.40951e-06
GAMG: Solving for p, Initial residual = 0.000453058, Final residual = 7.40762e-07, No Iterations 16
time step continuity errors : sum local = 1.98375e-10, global = 1.09144e-11, cumulative = 4.40952e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010918, Final residual = 3.40094e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176287, Final residual = 4.10029e-06, No Iterations 4
ExecutionTime = 19.48 s ClockTime = 20 s
Time = 1.9375
Courant Number mean: 0.129698 max: 0.61677
smoothSolver: Solving for Ux, Initial residual = 0.000828945, Final residual = 2.28175e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00217264, Final residual = 9.42944e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00278407, Final residual = 0.000198315, No Iterations 4
time step continuity errors : sum local = 5.31004e-08, global = 1.29038e-09, cumulative = 4.41081e-06
GAMG: Solving for p, Initial residual = 0.000453349, Final residual = 8.64197e-07, No Iterations 16
time step continuity errors : sum local = 2.31448e-10, global = 1.30715e-11, cumulative = 4.41083e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109315, Final residual = 3.41337e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176337, Final residual = 4.14064e-06, No Iterations 4
ExecutionTime = 19.5 s ClockTime = 20 s
Time = 1.94
Courant Number mean: 0.129729 max: 0.61677
smoothSolver: Solving for Ux, Initial residual = 0.000828547, Final residual = 2.29011e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0021744, Final residual = 9.46066e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00272219, Final residual = 0.000198643, No Iterations 4
time step continuity errors : sum local = 5.31933e-08, global = 1.27542e-09, cumulative = 4.4121e-06
GAMG: Solving for p, Initial residual = 0.000447959, Final residual = 8.22564e-07, No Iterations 16
time step continuity errors : sum local = 2.20318e-10, global = 1.23095e-11, cumulative = 4.41211e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109446, Final residual = 3.42513e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.001764, Final residual = 4.17709e-06, No Iterations 4
ExecutionTime = 19.52 s ClockTime = 20 s
Time = 1.9425
Courant Number mean: 0.12976 max: 0.616769
smoothSolver: Solving for Ux, Initial residual = 0.000828184, Final residual = 2.29755e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00217603, Final residual = 9.49211e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00276937, Final residual = 0.000202669, No Iterations 4
time step continuity errors : sum local = 5.42714e-08, global = 1.44754e-09, cumulative = 4.41356e-06
GAMG: Solving for p, Initial residual = 0.000450383, Final residual = 9.13824e-07, No Iterations 16
time step continuity errors : sum local = 2.44744e-10, global = 1.39932e-11, cumulative = 4.41358e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109556, Final residual = 3.44444e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176455, Final residual = 4.21042e-06, No Iterations 4
ExecutionTime = 19.55 s ClockTime = 20 s
Time = 1.945
Courant Number mean: 0.129791 max: 0.616769
smoothSolver: Solving for Ux, Initial residual = 0.000827809, Final residual = 2.30559e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00217785, Final residual = 9.52424e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00267538, Final residual = 0.000203887, No Iterations 4
time step continuity errors : sum local = 5.45947e-08, global = 1.46501e-09, cumulative = 4.41504e-06
GAMG: Solving for p, Initial residual = 0.00044548, Final residual = 8.91392e-07, No Iterations 16
time step continuity errors : sum local = 2.38724e-10, global = 1.35649e-11, cumulative = 4.41505e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109675, Final residual = 3.45396e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176503, Final residual = 4.24446e-06, No Iterations 4
ExecutionTime = 19.58 s ClockTime = 20 s
Time = 1.9475
Courant Number mean: 0.129822 max: 0.616768
smoothSolver: Solving for Ux, Initial residual = 0.000827384, Final residual = 2.31278e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0021797, Final residual = 9.55646e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00279455, Final residual = 0.000203062, No Iterations 4
time step continuity errors : sum local = 5.43693e-08, global = 1.58824e-09, cumulative = 4.41664e-06
GAMG: Solving for p, Initial residual = 0.000451365, Final residual = 5.62584e-07, No Iterations 18
time step continuity errors : sum local = 1.50653e-10, global = 9.05138e-12, cumulative = 4.41665e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109811, Final residual = 3.47062e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176541, Final residual = 4.28136e-06, No Iterations 4
ExecutionTime = 19.6 s ClockTime = 20 s
Time = 1.95
Courant Number mean: 0.129853 max: 0.616768
smoothSolver: Solving for Ux, Initial residual = 0.0008269, Final residual = 2.32094e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00218193, Final residual = 9.5892e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00283266, Final residual = 0.000212996, No Iterations 4
time step continuity errors : sum local = 5.70286e-08, global = 1.68364e-09, cumulative = 4.41834e-06
GAMG: Solving for p, Initial residual = 0.00045681, Final residual = 8.98342e-07, No Iterations 16
time step continuity errors : sum local = 2.4057e-10, global = 1.36153e-11, cumulative = 4.41835e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109949, Final residual = 3.48031e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176568, Final residual = 4.31681e-06, No Iterations 4
ExecutionTime = 19.62 s ClockTime = 20 s
Time = 1.9525
Courant Number mean: 0.129884 max: 0.616767
smoothSolver: Solving for Ux, Initial residual = 0.000826378, Final residual = 2.32836e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0021836, Final residual = 9.62083e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00278735, Final residual = 0.000208615, No Iterations 4
time step continuity errors : sum local = 5.58581e-08, global = 1.82391e-09, cumulative = 4.42017e-06
GAMG: Solving for p, Initial residual = 0.000451469, Final residual = 5.86077e-07, No Iterations 18
time step continuity errors : sum local = 1.56962e-10, global = 9.51798e-12, cumulative = 4.42018e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110098, Final residual = 3.49556e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017659, Final residual = 4.35501e-06, No Iterations 4
ExecutionTime = 19.65 s ClockTime = 20 s
Time = 1.955
Courant Number mean: 0.129915 max: 0.616767
smoothSolver: Solving for Ux, Initial residual = 0.000825894, Final residual = 2.33675e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00218561, Final residual = 9.65272e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00274686, Final residual = 0.000210297, No Iterations 4
time step continuity errors : sum local = 5.63178e-08, global = 1.87393e-09, cumulative = 4.42206e-06
GAMG: Solving for p, Initial residual = 0.000450877, Final residual = 5.39769e-07, No Iterations 18
time step continuity errors : sum local = 1.44588e-10, global = 8.59719e-12, cumulative = 4.42206e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110249, Final residual = 3.50829e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176614, Final residual = 4.39711e-06, No Iterations 4
ExecutionTime = 19.67 s ClockTime = 20 s
Time = 1.9575
Courant Number mean: 0.129946 max: 0.616767
smoothSolver: Solving for Ux, Initial residual = 0.00082537, Final residual = 2.3443e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00218763, Final residual = 9.68577e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00278013, Final residual = 0.000209206, No Iterations 4
time step continuity errors : sum local = 5.60399e-08, global = 1.56629e-09, cumulative = 4.42363e-06
GAMG: Solving for p, Initial residual = 0.000451875, Final residual = 9.76317e-07, No Iterations 16
time step continuity errors : sum local = 2.61621e-10, global = 1.52981e-11, cumulative = 4.42365e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0011038, Final residual = 3.51829e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176651, Final residual = 4.43271e-06, No Iterations 4
ExecutionTime = 19.69 s ClockTime = 20 s
Time = 1.96
Courant Number mean: 0.129977 max: 0.616766
smoothSolver: Solving for Ux, Initial residual = 0.000824805, Final residual = 2.35177e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00218964, Final residual = 9.71798e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00284728, Final residual = 0.000218015, No Iterations 4
time step continuity errors : sum local = 5.84028e-08, global = 3.10835e-09, cumulative = 4.42675e-06
GAMG: Solving for p, Initial residual = 0.000455508, Final residual = 6.27676e-07, No Iterations 18
time step continuity errors : sum local = 1.6816e-10, global = 1.04703e-11, cumulative = 4.42677e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110515, Final residual = 3.52834e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017667, Final residual = 4.47124e-06, No Iterations 4
ExecutionTime = 19.72 s ClockTime = 20 s
Time = 1.9625
Courant Number mean: 0.130007 max: 0.616766
smoothSolver: Solving for Ux, Initial residual = 0.000824204, Final residual = 2.36045e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00219152, Final residual = 9.74973e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00280018, Final residual = 0.000222763, No Iterations 4
time step continuity errors : sum local = 5.96641e-08, global = 2.1197e-09, cumulative = 4.42888e-06
GAMG: Solving for p, Initial residual = 0.000456411, Final residual = 5.75092e-07, No Iterations 18
time step continuity errors : sum local = 1.54048e-10, global = 9.31184e-12, cumulative = 4.42889e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110652, Final residual = 3.53956e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176694, Final residual = 4.5125e-06, No Iterations 4
ExecutionTime = 19.74 s ClockTime = 20 s
Time = 1.965
Courant Number mean: 0.130037 max: 0.616765
smoothSolver: Solving for Ux, Initial residual = 0.000823613, Final residual = 2.36644e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00219334, Final residual = 9.78279e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00285197, Final residual = 0.000221485, No Iterations 4
time step continuity errors : sum local = 5.93195e-08, global = 2.61398e-09, cumulative = 4.43151e-06
GAMG: Solving for p, Initial residual = 0.000462004, Final residual = 6.49791e-07, No Iterations 18
time step continuity errors : sum local = 1.74061e-10, global = 1.09402e-11, cumulative = 4.43152e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110796, Final residual = 3.55551e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176727, Final residual = 4.55248e-06, No Iterations 4
ExecutionTime = 19.76 s ClockTime = 20 s
Time = 1.9675
Courant Number mean: 0.130068 max: 0.616765
smoothSolver: Solving for Ux, Initial residual = 0.000823113, Final residual = 2.37423e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00219532, Final residual = 9.81411e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00284873, Final residual = 0.000220526, No Iterations 4
time step continuity errors : sum local = 5.90662e-08, global = 2.57074e-09, cumulative = 4.43409e-06
GAMG: Solving for p, Initial residual = 0.000462938, Final residual = 5.99368e-07, No Iterations 18
time step continuity errors : sum local = 1.60572e-10, global = 9.8414e-12, cumulative = 4.4341e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110943, Final residual = 3.56704e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176761, Final residual = 4.59186e-06, No Iterations 4
ExecutionTime = 19.79 s ClockTime = 20 s
Time = 1.97
Courant Number mean: 0.130099 max: 0.616764
smoothSolver: Solving for Ux, Initial residual = 0.000822706, Final residual = 2.38061e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00219725, Final residual = 9.84546e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00296144, Final residual = 0.000222456, No Iterations 4
time step continuity errors : sum local = 5.95832e-08, global = 2.68358e-09, cumulative = 4.43678e-06
GAMG: Solving for p, Initial residual = 0.00047115, Final residual = 6.35857e-07, No Iterations 18
time step continuity errors : sum local = 1.70334e-10, global = 1.06728e-11, cumulative = 4.43679e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111084, Final residual = 3.58543e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176798, Final residual = 4.63826e-06, No Iterations 4
ExecutionTime = 19.81 s ClockTime = 20 s
Time = 1.9725
Courant Number mean: 0.13013 max: 0.616764
smoothSolver: Solving for Ux, Initial residual = 0.000822327, Final residual = 2.38814e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00219892, Final residual = 9.87848e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00294117, Final residual = 0.000224583, No Iterations 4
time step continuity errors : sum local = 6.01526e-08, global = 2.74746e-09, cumulative = 4.43954e-06
GAMG: Solving for p, Initial residual = 0.000470173, Final residual = 6.16548e-07, No Iterations 18
time step continuity errors : sum local = 1.65162e-10, global = 1.02472e-11, cumulative = 4.43955e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111245, Final residual = 3.59502e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176843, Final residual = 4.67867e-06, No Iterations 4
ExecutionTime = 19.83 s ClockTime = 20 s
Time = 1.975
Courant Number mean: 0.130161 max: 0.616763
smoothSolver: Solving for Ux, Initial residual = 0.000821979, Final residual = 2.39485e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00220077, Final residual = 9.91119e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00307742, Final residual = 0.000226209, No Iterations 4
time step continuity errors : sum local = 6.05805e-08, global = 2.70643e-09, cumulative = 4.44226e-06
GAMG: Solving for p, Initial residual = 0.000482385, Final residual = 6.52973e-07, No Iterations 18
time step continuity errors : sum local = 1.74888e-10, global = 1.10714e-11, cumulative = 4.44227e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111396, Final residual = 3.60491e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176886, Final residual = 4.72175e-06, No Iterations 4
ExecutionTime = 19.86 s ClockTime = 20 s
Time = 1.9775
Courant Number mean: 0.130192 max: 0.616763
smoothSolver: Solving for Ux, Initial residual = 0.00082174, Final residual = 2.4024e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00220238, Final residual = 9.94519e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00307412, Final residual = 0.000227071, No Iterations 4
time step continuity errors : sum local = 6.08042e-08, global = 2.8069e-09, cumulative = 4.44508e-06
GAMG: Solving for p, Initial residual = 0.000485864, Final residual = 6.43303e-07, No Iterations 18
time step continuity errors : sum local = 1.72286e-10, global = 1.08316e-11, cumulative = 4.44509e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111549, Final residual = 3.62059e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176907, Final residual = 4.7637e-06, No Iterations 4
ExecutionTime = 19.88 s ClockTime = 20 s
Time = 1.98
Courant Number mean: 0.130222 max: 0.616762
smoothSolver: Solving for Ux, Initial residual = 0.000821554, Final residual = 2.40849e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00220402, Final residual = 9.98e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00315229, Final residual = 0.000228505, No Iterations 4
time step continuity errors : sum local = 6.11873e-08, global = 2.99856e-09, cumulative = 4.44809e-06
GAMG: Solving for p, Initial residual = 0.000484926, Final residual = 6.60862e-07, No Iterations 18
time step continuity errors : sum local = 1.76988e-10, global = 1.12057e-11, cumulative = 4.4481e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111698, Final residual = 3.63658e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176934, Final residual = 4.80587e-06, No Iterations 4
ExecutionTime = 19.9 s ClockTime = 20 s
Time = 1.9825
Courant Number mean: 0.130253 max: 0.616762
smoothSolver: Solving for Ux, Initial residual = 0.000821353, Final residual = 2.41517e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00220569, Final residual = 2.63363e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00303279, Final residual = 0.000223132, No Iterations 4
time step continuity errors : sum local = 5.97545e-08, global = 2.99731e-09, cumulative = 4.45109e-06
GAMG: Solving for p, Initial residual = 0.000455923, Final residual = 9.73813e-07, No Iterations 14
time step continuity errors : sum local = 2.60843e-10, global = 1.27077e-11, cumulative = 4.45111e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111839, Final residual = 3.64466e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176972, Final residual = 4.84756e-06, No Iterations 4
ExecutionTime = 19.93 s ClockTime = 20 s
Time = 1.985
Courant Number mean: 0.130283 max: 0.616761
smoothSolver: Solving for Ux, Initial residual = 0.000821136, Final residual = 2.4221e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00220678, Final residual = 2.63332e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0029615, Final residual = 0.000223088, No Iterations 4
time step continuity errors : sum local = 5.9748e-08, global = 3.18149e-09, cumulative = 4.45429e-06
GAMG: Solving for p, Initial residual = 0.000446161, Final residual = 9.69998e-07, No Iterations 14
time step continuity errors : sum local = 2.59843e-10, global = 1.2652e-11, cumulative = 4.4543e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111964, Final residual = 3.65362e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017703, Final residual = 4.89054e-06, No Iterations 4
ExecutionTime = 19.95 s ClockTime = 20 s
Time = 1.9875
Courant Number mean: 0.130314 max: 0.616761
smoothSolver: Solving for Ux, Initial residual = 0.00082084, Final residual = 2.42871e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00220848, Final residual = 2.65173e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00299809, Final residual = 0.000225056, No Iterations 4
time step continuity errors : sum local = 6.02773e-08, global = 3.29768e-09, cumulative = 4.4576e-06
GAMG: Solving for p, Initial residual = 0.000444909, Final residual = 9.842e-07, No Iterations 14
time step continuity errors : sum local = 2.63654e-10, global = 1.29255e-11, cumulative = 4.45761e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112081, Final residual = 3.66826e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177092, Final residual = 4.93381e-06, No Iterations 4
ExecutionTime = 19.97 s ClockTime = 20 s
Time = 1.99
Courant Number mean: 0.130344 max: 0.61676
smoothSolver: Solving for Ux, Initial residual = 0.000820468, Final residual = 2.43592e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00221012, Final residual = 2.6625e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00284529, Final residual = 0.000224529, No Iterations 4
time step continuity errors : sum local = 6.01352e-08, global = 3.28856e-09, cumulative = 4.4609e-06
GAMG: Solving for p, Initial residual = 0.0004374, Final residual = 5.08667e-07, No Iterations 16
time step continuity errors : sum local = 1.36256e-10, global = 7.18988e-12, cumulative = 4.46091e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112218, Final residual = 3.68718e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017717, Final residual = 4.97749e-06, No Iterations 4
ExecutionTime = 20 s ClockTime = 20 s
Time = 1.9925
Courant Number mean: 0.130375 max: 0.61676
smoothSolver: Solving for Ux, Initial residual = 0.000820015, Final residual = 2.44196e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00221233, Final residual = 2.6769e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00277715, Final residual = 0.000228477, No Iterations 4
time step continuity errors : sum local = 6.11911e-08, global = 3.42305e-09, cumulative = 4.46433e-06
GAMG: Solving for p, Initial residual = 0.000437932, Final residual = 9.99507e-07, No Iterations 14
time step continuity errors : sum local = 2.67739e-10, global = 1.34363e-11, cumulative = 4.46434e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112336, Final residual = 3.69189e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177241, Final residual = 5.02456e-06, No Iterations 4
ExecutionTime = 20.02 s ClockTime = 20 s
Time = 1.995
Courant Number mean: 0.130405 max: 0.616759
smoothSolver: Solving for Ux, Initial residual = 0.000819594, Final residual = 2.44871e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00221418, Final residual = 2.69011e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0028818, Final residual = 0.000228388, No Iterations 4
time step continuity errors : sum local = 6.11649e-08, global = 3.56863e-09, cumulative = 4.46791e-06
GAMG: Solving for p, Initial residual = 0.000444373, Final residual = 9.87266e-07, No Iterations 14
time step continuity errors : sum local = 2.64439e-10, global = 1.33004e-11, cumulative = 4.46793e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112461, Final residual = 3.70153e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177299, Final residual = 5.0706e-06, No Iterations 4
ExecutionTime = 20.04 s ClockTime = 20 s
Time = 1.9975
Courant Number mean: 0.130436 max: 0.616759
smoothSolver: Solving for Ux, Initial residual = 0.00081922, Final residual = 2.45463e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00221613, Final residual = 2.70339e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00283585, Final residual = 0.000228983, No Iterations 4
time step continuity errors : sum local = 6.13224e-08, global = 3.65258e-09, cumulative = 4.47158e-06
GAMG: Solving for p, Initial residual = 0.000441413, Final residual = 5.15826e-07, No Iterations 16
time step continuity errors : sum local = 1.38169e-10, global = 7.44768e-12, cumulative = 4.47159e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112611, Final residual = 3.71201e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177357, Final residual = 5.11327e-06, No Iterations 4
ExecutionTime = 20.06 s ClockTime = 20 s
Time = 2
Courant Number mean: 0.130467 max: 0.616758
smoothSolver: Solving for Ux, Initial residual = 0.000818749, Final residual = 2.46108e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0022182, Final residual = 2.71681e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00282788, Final residual = 0.000229244, No Iterations 4
time step continuity errors : sum local = 6.13982e-08, global = 3.72151e-09, cumulative = 4.47531e-06
GAMG: Solving for p, Initial residual = 0.000439726, Final residual = 5.19154e-07, No Iterations 16
time step continuity errors : sum local = 1.3908e-10, global = 7.50038e-12, cumulative = 4.47531e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112753, Final residual = 3.7221e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177414, Final residual = 5.15563e-06, No Iterations 4
ExecutionTime = 20.11 s ClockTime = 20 s
Time = 2.0025
Courant Number mean: 0.130497 max: 0.616758
smoothSolver: Solving for Ux, Initial residual = 0.000818217, Final residual = 2.46675e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00222032, Final residual = 2.73078e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00289121, Final residual = 0.000229199, No Iterations 4
time step continuity errors : sum local = 6.13902e-08, global = 3.80148e-09, cumulative = 4.47912e-06
GAMG: Solving for p, Initial residual = 0.000438942, Final residual = 5.17211e-07, No Iterations 16
time step continuity errors : sum local = 1.38559e-10, global = 7.57316e-12, cumulative = 4.47912e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112917, Final residual = 3.73142e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017744, Final residual = 5.19814e-06, No Iterations 4
ExecutionTime = 20.13 s ClockTime = 20 s
Time = 2.005
Courant Number mean: 0.130529 max: 0.616757
smoothSolver: Solving for Ux, Initial residual = 0.000817649, Final residual = 2.47274e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0022225, Final residual = 2.74471e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00288475, Final residual = 0.000229669, No Iterations 4
time step continuity errors : sum local = 6.15169e-08, global = 3.87403e-09, cumulative = 4.483e-06
GAMG: Solving for p, Initial residual = 0.000439673, Final residual = 5.18799e-07, No Iterations 16
time step continuity errors : sum local = 1.38987e-10, global = 7.63917e-12, cumulative = 4.48301e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113071, Final residual = 3.74437e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017749, Final residual = 5.24647e-06, No Iterations 4
ExecutionTime = 20.15 s ClockTime = 20 s
Time = 2.0075
Courant Number mean: 0.13056 max: 0.616757
smoothSolver: Solving for Ux, Initial residual = 0.000817083, Final residual = 2.47894e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00222459, Final residual = 2.75869e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00279138, Final residual = 0.000228833, No Iterations 4
time step continuity errors : sum local = 6.12931e-08, global = 3.88643e-09, cumulative = 4.48689e-06
GAMG: Solving for p, Initial residual = 0.000435545, Final residual = 5.29825e-07, No Iterations 16
time step continuity errors : sum local = 1.41941e-10, global = 7.91094e-12, cumulative = 4.4869e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113223, Final residual = 3.75745e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177533, Final residual = 5.28957e-06, No Iterations 4
ExecutionTime = 20.18 s ClockTime = 20 s
Time = 2.01
Courant Number mean: 0.130591 max: 0.616756
smoothSolver: Solving for Ux, Initial residual = 0.000816584, Final residual = 2.48506e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00222686, Final residual = 2.77308e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00283525, Final residual = 0.000228792, No Iterations 4
time step continuity errors : sum local = 6.12829e-08, global = 3.92463e-09, cumulative = 4.49082e-06
GAMG: Solving for p, Initial residual = 0.000441445, Final residual = 5.23359e-07, No Iterations 16
time step continuity errors : sum local = 1.40206e-10, global = 7.78766e-12, cumulative = 4.49083e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113361, Final residual = 3.77667e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177575, Final residual = 5.33039e-06, No Iterations 4
ExecutionTime = 20.2 s ClockTime = 20 s
Time = 2.0125
Courant Number mean: 0.130622 max: 0.616756
smoothSolver: Solving for Ux, Initial residual = 0.000816151, Final residual = 2.49099e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0022289, Final residual = 2.78735e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0029359, Final residual = 0.000228149, No Iterations 4
time step continuity errors : sum local = 6.11119e-08, global = 3.96888e-09, cumulative = 4.4948e-06
GAMG: Solving for p, Initial residual = 0.000446463, Final residual = 5.36765e-07, No Iterations 16
time step continuity errors : sum local = 1.43806e-10, global = 8.03652e-12, cumulative = 4.49481e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113502, Final residual = 3.7964e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017761, Final residual = 5.372e-06, No Iterations 4
ExecutionTime = 20.23 s ClockTime = 20 s
Time = 2.015
Courant Number mean: 0.130653 max: 0.616755
smoothSolver: Solving for Ux, Initial residual = 0.000815622, Final residual = 2.49692e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00223077, Final residual = 2.80178e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00302961, Final residual = 0.000231943, No Iterations 4
time step continuity errors : sum local = 6.214e-08, global = 4.03109e-09, cumulative = 4.49884e-06
GAMG: Solving for p, Initial residual = 0.000449032, Final residual = 5.29003e-07, No Iterations 16
time step continuity errors : sum local = 1.41773e-10, global = 7.93636e-12, cumulative = 4.49885e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113636, Final residual = 3.81175e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017765, Final residual = 5.41193e-06, No Iterations 4
ExecutionTime = 20.25 s ClockTime = 20 s
Time = 2.0175
Courant Number mean: 0.130683 max: 0.616755
smoothSolver: Solving for Ux, Initial residual = 0.000815156, Final residual = 2.5026e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00223253, Final residual = 2.81611e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00321554, Final residual = 0.00022638, No Iterations 4
time step continuity errors : sum local = 6.067e-08, global = 4.2803e-09, cumulative = 4.50313e-06
GAMG: Solving for p, Initial residual = 0.000461472, Final residual = 5.22888e-07, No Iterations 16
time step continuity errors : sum local = 1.40194e-10, global = 7.74878e-12, cumulative = 4.50314e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113749, Final residual = 3.82837e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177689, Final residual = 5.45835e-06, No Iterations 4
ExecutionTime = 20.27 s ClockTime = 20 s
Time = 2.02
Courant Number mean: 0.130713 max: 0.616754
smoothSolver: Solving for Ux, Initial residual = 0.000814701, Final residual = 2.50757e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00223429, Final residual = 2.83097e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00322224, Final residual = 0.000232164, No Iterations 4
time step continuity errors : sum local = 6.22187e-08, global = 4.38068e-09, cumulative = 4.50752e-06
GAMG: Solving for p, Initial residual = 0.000469891, Final residual = 5.30081e-07, No Iterations 16
time step continuity errors : sum local = 1.42057e-10, global = 7.77245e-12, cumulative = 4.50752e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113883, Final residual = 3.84328e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177734, Final residual = 5.49937e-06, No Iterations 4
ExecutionTime = 20.29 s ClockTime = 20 s
Time = 2.0225
Courant Number mean: 0.130742 max: 0.616754
smoothSolver: Solving for Ux, Initial residual = 0.000814397, Final residual = 2.51355e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00223578, Final residual = 2.84567e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0029917, Final residual = 0.000228056, No Iterations 4
time step continuity errors : sum local = 6.11037e-08, global = 4.39877e-09, cumulative = 4.51192e-06
GAMG: Solving for p, Initial residual = 0.000456925, Final residual = 5.2896e-07, No Iterations 16
time step continuity errors : sum local = 1.41746e-10, global = 7.85295e-12, cumulative = 4.51193e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114013, Final residual = 3.85648e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177779, Final residual = 5.54249e-06, No Iterations 4
ExecutionTime = 20.32 s ClockTime = 20 s
Time = 2.025
Courant Number mean: 0.13077 max: 0.616754
smoothSolver: Solving for Ux, Initial residual = 0.000814073, Final residual = 2.51907e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00223754, Final residual = 2.8603e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00287288, Final residual = 0.00023053, No Iterations 4
time step continuity errors : sum local = 6.17645e-08, global = 4.45036e-09, cumulative = 4.51638e-06
GAMG: Solving for p, Initial residual = 0.000450754, Final residual = 5.31475e-07, No Iterations 16
time step continuity errors : sum local = 1.42433e-10, global = 7.95057e-12, cumulative = 4.51639e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114133, Final residual = 3.87e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017782, Final residual = 5.58199e-06, No Iterations 4
ExecutionTime = 20.34 s ClockTime = 20 s
Time = 2.0275
Courant Number mean: 0.130799 max: 0.616753
smoothSolver: Solving for Ux, Initial residual = 0.000813853, Final residual = 2.5248e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00223886, Final residual = 2.87525e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00298765, Final residual = 0.000229467, No Iterations 4
time step continuity errors : sum local = 6.14876e-08, global = 4.50673e-09, cumulative = 4.5209e-06
GAMG: Solving for p, Initial residual = 0.000457629, Final residual = 5.32432e-07, No Iterations 16
time step continuity errors : sum local = 1.42713e-10, global = 8.05056e-12, cumulative = 4.5209e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114232, Final residual = 3.88382e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017785, Final residual = 5.62186e-06, No Iterations 4
ExecutionTime = 20.36 s ClockTime = 20 s
Time = 2.03
Courant Number mean: 0.130826 max: 0.616753
smoothSolver: Solving for Ux, Initial residual = 0.000813669, Final residual = 2.53004e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00224017, Final residual = 2.89032e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00320005, Final residual = 0.000231214, No Iterations 4
time step continuity errors : sum local = 6.19619e-08, global = 4.59303e-09, cumulative = 4.5255e-06
GAMG: Solving for p, Initial residual = 0.000467072, Final residual = 5.4638e-07, No Iterations 16
time step continuity errors : sum local = 1.46448e-10, global = 8.21753e-12, cumulative = 4.52551e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114386, Final residual = 3.89885e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177871, Final residual = 5.66231e-06, No Iterations 4
ExecutionTime = 20.38 s ClockTime = 21 s
Time = 2.0325
Courant Number mean: 0.130854 max: 0.616752
smoothSolver: Solving for Ux, Initial residual = 0.000813398, Final residual = 2.53553e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00224174, Final residual = 2.90527e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00310267, Final residual = 0.000230697, No Iterations 4
time step continuity errors : sum local = 6.18168e-08, global = 4.62659e-09, cumulative = 4.53013e-06
GAMG: Solving for p, Initial residual = 0.00045682, Final residual = 5.45714e-07, No Iterations 16
time step continuity errors : sum local = 1.46251e-10, global = 8.29098e-12, cumulative = 4.53014e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114562, Final residual = 3.91416e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177911, Final residual = 5.69905e-06, No Iterations 4
ExecutionTime = 20.41 s ClockTime = 21 s
Time = 2.035
Courant Number mean: 0.13088 max: 0.616752
smoothSolver: Solving for Ux, Initial residual = 0.000813117, Final residual = 2.54077e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00224317, Final residual = 2.92012e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00324904, Final residual = 0.000230211, No Iterations 4
time step continuity errors : sum local = 6.16826e-08, global = 4.63539e-09, cumulative = 4.53478e-06
GAMG: Solving for p, Initial residual = 0.000463611, Final residual = 5.4594e-07, No Iterations 16
time step continuity errors : sum local = 1.4631e-10, global = 8.368e-12, cumulative = 4.53478e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114733, Final residual = 3.9299e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177957, Final residual = 5.73505e-06, No Iterations 4
ExecutionTime = 20.43 s ClockTime = 21 s
Time = 2.0375
Courant Number mean: 0.130907 max: 0.616751
smoothSolver: Solving for Ux, Initial residual = 0.000812818, Final residual = 2.54613e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00224479, Final residual = 2.9355e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00332443, Final residual = 0.000233054, No Iterations 4
time step continuity errors : sum local = 6.24487e-08, global = 4.75253e-09, cumulative = 4.53954e-06
GAMG: Solving for p, Initial residual = 0.000467726, Final residual = 5.68234e-07, No Iterations 16
time step continuity errors : sum local = 1.52299e-10, global = 8.58768e-12, cumulative = 4.53955e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114915, Final residual = 3.94533e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178007, Final residual = 5.77714e-06, No Iterations 4
ExecutionTime = 20.45 s ClockTime = 21 s
Time = 2.04
Courant Number mean: 0.130933 max: 0.616751
smoothSolver: Solving for Ux, Initial residual = 0.000812474, Final residual = 2.55134e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0022464, Final residual = 2.95031e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00305309, Final residual = 0.000234642, No Iterations 4
time step continuity errors : sum local = 6.28817e-08, global = 4.78716e-09, cumulative = 4.54433e-06
GAMG: Solving for p, Initial residual = 0.00045279, Final residual = 5.745e-07, No Iterations 16
time step continuity errors : sum local = 1.53997e-10, global = 8.73646e-12, cumulative = 4.54434e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00115093, Final residual = 3.96834e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178064, Final residual = 5.81281e-06, No Iterations 4
ExecutionTime = 20.47 s ClockTime = 21 s
Time = 2.0425
Courant Number mean: 0.130959 max: 0.616751
smoothSolver: Solving for Ux, Initial residual = 0.00081218, Final residual = 2.55712e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00224814, Final residual = 2.96535e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00297277, Final residual = 0.000233942, No Iterations 4
time step continuity errors : sum local = 6.26952e-08, global = 4.81928e-09, cumulative = 4.54916e-06
GAMG: Solving for p, Initial residual = 0.000448493, Final residual = 5.72496e-07, No Iterations 16
time step continuity errors : sum local = 1.53455e-10, global = 8.7288e-12, cumulative = 4.54917e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00115256, Final residual = 3.98345e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178123, Final residual = 5.8473e-06, No Iterations 4
ExecutionTime = 20.5 s ClockTime = 21 s
Time = 2.045
Courant Number mean: 0.130985 max: 0.61675
smoothSolver: Solving for Ux, Initial residual = 0.000811821, Final residual = 2.56252e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00225012, Final residual = 2.98035e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00302059, Final residual = 0.00023408, No Iterations 4
time step continuity errors : sum local = 6.27306e-08, global = 4.84097e-09, cumulative = 4.55401e-06
GAMG: Solving for p, Initial residual = 0.000451716, Final residual = 5.79868e-07, No Iterations 16
time step continuity errors : sum local = 1.55427e-10, global = 8.86639e-12, cumulative = 4.55402e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00115425, Final residual = 4.00405e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178179, Final residual = 5.8817e-06, No Iterations 4
ExecutionTime = 20.52 s ClockTime = 21 s
Time = 2.0475
Courant Number mean: 0.131012 max: 0.61675
smoothSolver: Solving for Ux, Initial residual = 0.000811385, Final residual = 2.56788e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00225231, Final residual = 2.99547e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00301047, Final residual = 0.000236386, No Iterations 4
time step continuity errors : sum local = 6.335e-08, global = 4.90739e-09, cumulative = 4.55893e-06
GAMG: Solving for p, Initial residual = 0.000450623, Final residual = 5.79924e-07, No Iterations 16
time step continuity errors : sum local = 1.5545e-10, global = 8.89698e-12, cumulative = 4.55894e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00115594, Final residual = 4.01806e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178235, Final residual = 5.92099e-06, No Iterations 4
ExecutionTime = 20.54 s ClockTime = 21 s
Time = 2.05
Courant Number mean: 0.131041 max: 0.616749
smoothSolver: Solving for Ux, Initial residual = 0.000810919, Final residual = 2.5731e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00225483, Final residual = 3.01038e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00296606, Final residual = 0.000237148, No Iterations 4
time step continuity errors : sum local = 6.35574e-08, global = 4.95525e-09, cumulative = 4.56389e-06
GAMG: Solving for p, Initial residual = 0.00044848, Final residual = 5.87975e-07, No Iterations 16
time step continuity errors : sum local = 1.57618e-10, global = 9.03013e-12, cumulative = 4.5639e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00115757, Final residual = 4.0332e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017829, Final residual = 5.95223e-06, No Iterations 4
ExecutionTime = 20.56 s ClockTime = 21 s
Time = 2.0525
Courant Number mean: 0.13107 max: 0.616749
smoothSolver: Solving for Ux, Initial residual = 0.000810565, Final residual = 2.5784e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00225743, Final residual = 3.02533e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00302504, Final residual = 0.000238155, No Iterations 4
time step continuity errors : sum local = 6.38312e-08, global = 5.00566e-09, cumulative = 4.56891e-06
GAMG: Solving for p, Initial residual = 0.00045493, Final residual = 5.92358e-07, No Iterations 16
time step continuity errors : sum local = 1.58797e-10, global = 9.16389e-12, cumulative = 4.56891e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00115932, Final residual = 4.05545e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178329, Final residual = 5.98349e-06, No Iterations 4
ExecutionTime = 20.58 s ClockTime = 21 s
Time = 2.055
Courant Number mean: 0.131101 max: 0.616749
smoothSolver: Solving for Ux, Initial residual = 0.000810239, Final residual = 2.58382e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00226002, Final residual = 3.04024e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00302223, Final residual = 0.000238945, No Iterations 4
time step continuity errors : sum local = 6.40382e-08, global = 5.03521e-09, cumulative = 4.57395e-06
GAMG: Solving for p, Initial residual = 0.000457414, Final residual = 6.05001e-07, No Iterations 16
time step continuity errors : sum local = 1.62163e-10, global = 9.43743e-12, cumulative = 4.57396e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116093, Final residual = 4.07017e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178376, Final residual = 6.0171e-06, No Iterations 4
ExecutionTime = 20.6 s ClockTime = 21 s
Time = 2.0575
Courant Number mean: 0.131132 max: 0.616748
smoothSolver: Solving for Ux, Initial residual = 0.000809825, Final residual = 2.58906e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00226235, Final residual = 3.05563e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00294697, Final residual = 0.000238904, No Iterations 4
time step continuity errors : sum local = 6.40256e-08, global = 5.08057e-09, cumulative = 4.57904e-06
GAMG: Solving for p, Initial residual = 0.00044823, Final residual = 6.02729e-07, No Iterations 16
time step continuity errors : sum local = 1.61565e-10, global = 9.36218e-12, cumulative = 4.57905e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116239, Final residual = 4.08669e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178422, Final residual = 6.04551e-06, No Iterations 4
ExecutionTime = 20.63 s ClockTime = 21 s
Time = 2.06
Courant Number mean: 0.131163 max: 0.616748
smoothSolver: Solving for Ux, Initial residual = 0.000809416, Final residual = 2.59456e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00226464, Final residual = 3.07053e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00299332, Final residual = 0.000238108, No Iterations 4
time step continuity errors : sum local = 6.38185e-08, global = 5.10693e-09, cumulative = 4.58416e-06
GAMG: Solving for p, Initial residual = 0.000451836, Final residual = 6.11739e-07, No Iterations 16
time step continuity errors : sum local = 1.64003e-10, global = 9.52617e-12, cumulative = 4.58417e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116388, Final residual = 4.10281e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178474, Final residual = 6.07681e-06, No Iterations 4
ExecutionTime = 20.65 s ClockTime = 21 s
Time = 2.0625
Courant Number mean: 0.131193 max: 0.616748
smoothSolver: Solving for Ux, Initial residual = 0.000808961, Final residual = 2.60005e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00226687, Final residual = 3.08528e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00323613, Final residual = 0.00023919, No Iterations 4
time step continuity errors : sum local = 6.41198e-08, global = 5.13542e-09, cumulative = 4.5893e-06
GAMG: Solving for p, Initial residual = 0.00046744, Final residual = 6.045e-07, No Iterations 16
time step continuity errors : sum local = 1.62097e-10, global = 9.47877e-12, cumulative = 4.58931e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116521, Final residual = 4.11963e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178511, Final residual = 6.10524e-06, No Iterations 4
ExecutionTime = 20.67 s ClockTime = 21 s
Time = 2.065
Courant Number mean: 0.131224 max: 0.616747
smoothSolver: Solving for Ux, Initial residual = 0.000808473, Final residual = 2.6054e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00226898, Final residual = 3.09975e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00334231, Final residual = 0.000239238, No Iterations 4
time step continuity errors : sum local = 6.41376e-08, global = 5.12645e-09, cumulative = 4.59444e-06
GAMG: Solving for p, Initial residual = 0.000478152, Final residual = 6.17146e-07, No Iterations 16
time step continuity errors : sum local = 1.65478e-10, global = 9.60655e-12, cumulative = 4.59445e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116649, Final residual = 4.13659e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017853, Final residual = 6.13079e-06, No Iterations 4
ExecutionTime = 20.7 s ClockTime = 21 s
Time = 2.0675
Courant Number mean: 0.131253 max: 0.616747
smoothSolver: Solving for Ux, Initial residual = 0.000808059, Final residual = 2.61132e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00227048, Final residual = 3.11407e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00330352, Final residual = 0.000243805, No Iterations 4
time step continuity errors : sum local = 6.53616e-08, global = 5.17896e-09, cumulative = 4.59963e-06
GAMG: Solving for p, Initial residual = 0.000485546, Final residual = 6.22363e-07, No Iterations 16
time step continuity errors : sum local = 1.66883e-10, global = 9.68204e-12, cumulative = 4.59964e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116782, Final residual = 4.15338e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178554, Final residual = 6.15552e-06, No Iterations 4
ExecutionTime = 20.72 s ClockTime = 21 s
Time = 2.07
Courant Number mean: 0.131283 max: 0.616747
smoothSolver: Solving for Ux, Initial residual = 0.00080773, Final residual = 2.61745e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00227193, Final residual = 3.1283e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00315693, Final residual = 0.000241162, No Iterations 4
time step continuity errors : sum local = 6.46618e-08, global = 5.1629e-09, cumulative = 4.6048e-06
GAMG: Solving for p, Initial residual = 0.000480076, Final residual = 6.32073e-07, No Iterations 16
time step continuity errors : sum local = 1.69528e-10, global = 9.96274e-12, cumulative = 4.60481e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116942, Final residual = 4.17035e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178572, Final residual = 6.17783e-06, No Iterations 4
ExecutionTime = 20.75 s ClockTime = 21 s
Time = 2.0725
Courant Number mean: 0.131311 max: 0.616746
smoothSolver: Solving for Ux, Initial residual = 0.000807304, Final residual = 2.62346e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00227385, Final residual = 3.14306e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00304223, Final residual = 0.000245281, No Iterations 4
time step continuity errors : sum local = 6.57833e-08, global = 5.29009e-09, cumulative = 4.6101e-06
GAMG: Solving for p, Initial residual = 0.000470708, Final residual = 6.40323e-07, No Iterations 16
time step continuity errors : sum local = 1.7178e-10, global = 9.96404e-12, cumulative = 4.61011e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00117099, Final residual = 4.19505e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178595, Final residual = 6.2005e-06, No Iterations 4
ExecutionTime = 20.77 s ClockTime = 21 s
Time = 2.075
Courant Number mean: 0.131339 max: 0.616746
smoothSolver: Solving for Ux, Initial residual = 0.000806918, Final residual = 2.62972e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00227522, Final residual = 3.15691e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00320832, Final residual = 0.000246446, No Iterations 4
time step continuity errors : sum local = 6.61129e-08, global = 5.23741e-09, cumulative = 4.61535e-06
GAMG: Solving for p, Initial residual = 0.000480647, Final residual = 6.27413e-07, No Iterations 16
time step continuity errors : sum local = 1.68375e-10, global = 9.97638e-12, cumulative = 4.61536e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00117256, Final residual = 4.21299e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178622, Final residual = 6.22239e-06, No Iterations 4
ExecutionTime = 20.79 s ClockTime = 21 s
Time = 2.0775
Courant Number mean: 0.131367 max: 0.616746
smoothSolver: Solving for Ux, Initial residual = 0.000806575, Final residual = 2.6362e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00227684, Final residual = 3.17143e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00325241, Final residual = 0.000247113, No Iterations 4
time step continuity errors : sum local = 6.62903e-08, global = 5.33236e-09, cumulative = 4.62069e-06
GAMG: Solving for p, Initial residual = 0.000482509, Final residual = 6.51951e-07, No Iterations 16
time step continuity errors : sum local = 1.74894e-10, global = 1.01967e-11, cumulative = 4.6207e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00117419, Final residual = 4.23354e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178653, Final residual = 6.2419e-06, No Iterations 4
ExecutionTime = 20.81 s ClockTime = 21 s
Time = 2.08
Courant Number mean: 0.131394 max: 0.616746
smoothSolver: Solving for Ux, Initial residual = 0.000806422, Final residual = 2.64288e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00227812, Final residual = 3.18579e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00305244, Final residual = 0.000247859, No Iterations 4
time step continuity errors : sum local = 6.64857e-08, global = 5.31077e-09, cumulative = 4.62601e-06
GAMG: Solving for p, Initial residual = 0.000467677, Final residual = 6.33776e-07, No Iterations 16
time step continuity errors : sum local = 1.70048e-10, global = 1.00633e-11, cumulative = 4.62602e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00117554, Final residual = 4.25092e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178666, Final residual = 6.26119e-06, No Iterations 4
ExecutionTime = 20.84 s ClockTime = 21 s
Time = 2.0825
Courant Number mean: 0.13142 max: 0.616745
smoothSolver: Solving for Ux, Initial residual = 0.000806193, Final residual = 2.64976e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00227977, Final residual = 3.20029e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00321909, Final residual = 0.000248265, No Iterations 4
time step continuity errors : sum local = 6.66086e-08, global = 5.3466e-09, cumulative = 4.63137e-06
GAMG: Solving for p, Initial residual = 0.000470418, Final residual = 8.42628e-07, No Iterations 16
time step continuity errors : sum local = 2.2613e-10, global = 1.51947e-11, cumulative = 4.63138e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00117699, Final residual = 4.27371e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178682, Final residual = 6.27874e-06, No Iterations 4
ExecutionTime = 20.86 s ClockTime = 21 s
Time = 2.085
Courant Number mean: 0.131446 max: 0.616745
smoothSolver: Solving for Ux, Initial residual = 0.00080598, Final residual = 2.65712e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00228117, Final residual = 3.21513e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00322212, Final residual = 0.000248032, No Iterations 4
time step continuity errors : sum local = 6.65551e-08, global = 5.4284e-09, cumulative = 4.63681e-06
GAMG: Solving for p, Initial residual = 0.000473927, Final residual = 8.0088e-07, No Iterations 16
time step continuity errors : sum local = 2.14922e-10, global = 1.39569e-11, cumulative = 4.63682e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00117852, Final residual = 4.29086e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178708, Final residual = 6.29762e-06, No Iterations 4
ExecutionTime = 20.88 s ClockTime = 21 s
Time = 2.0875
Courant Number mean: 0.131471 max: 0.616745
smoothSolver: Solving for Ux, Initial residual = 0.000805621, Final residual = 2.66301e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00228273, Final residual = 3.22895e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00330237, Final residual = 0.000249033, No Iterations 4
time step continuity errors : sum local = 6.68178e-08, global = 5.43593e-09, cumulative = 4.64226e-06
GAMG: Solving for p, Initial residual = 0.000482683, Final residual = 8.19689e-07, No Iterations 16
time step continuity errors : sum local = 2.19932e-10, global = 1.45574e-11, cumulative = 4.64227e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00118005, Final residual = 4.3073e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178748, Final residual = 6.32137e-06, No Iterations 4
ExecutionTime = 20.91 s ClockTime = 21 s
Time = 2.09
Courant Number mean: 0.131496 max: 0.616744
smoothSolver: Solving for Ux, Initial residual = 0.000805295, Final residual = 2.66997e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00228402, Final residual = 3.24363e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0032899, Final residual = 0.000249344, No Iterations 4
time step continuity errors : sum local = 6.68979e-08, global = 5.41634e-09, cumulative = 4.64769e-06
GAMG: Solving for p, Initial residual = 0.000480543, Final residual = 8.4292e-07, No Iterations 16
time step continuity errors : sum local = 2.26163e-10, global = 1.51813e-11, cumulative = 4.6477e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00118154, Final residual = 4.32285e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178792, Final residual = 6.33507e-06, No Iterations 4
ExecutionTime = 20.93 s ClockTime = 21 s
Time = 2.0925
Courant Number mean: 0.131521 max: 0.616744
smoothSolver: Solving for Ux, Initial residual = 0.000804971, Final residual = 2.67694e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0022854, Final residual = 3.25749e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00317434, Final residual = 0.000249419, No Iterations 4
time step continuity errors : sum local = 6.69196e-08, global = 5.43882e-09, cumulative = 4.65314e-06
GAMG: Solving for p, Initial residual = 0.000473844, Final residual = 8.68231e-07, No Iterations 16
time step continuity errors : sum local = 2.32983e-10, global = 1.5785e-11, cumulative = 4.65316e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00118306, Final residual = 4.33945e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178823, Final residual = 6.34808e-06, No Iterations 4
ExecutionTime = 20.96 s ClockTime = 21 s
Time = 2.095
Courant Number mean: 0.131546 max: 0.616744
smoothSolver: Solving for Ux, Initial residual = 0.000804629, Final residual = 2.68339e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.002287, Final residual = 3.27175e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00314807, Final residual = 0.000248651, No Iterations 4
time step continuity errors : sum local = 6.67304e-08, global = 5.42302e-09, cumulative = 4.65858e-06
GAMG: Solving for p, Initial residual = 0.000472232, Final residual = 8.54622e-07, No Iterations 16
time step continuity errors : sum local = 2.29393e-10, global = 1.55223e-11, cumulative = 4.6586e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00118447, Final residual = 4.35456e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017885, Final residual = 6.36085e-06, No Iterations 4
ExecutionTime = 20.99 s ClockTime = 21 s
Time = 2.0975
Courant Number mean: 0.131573 max: 0.616744
smoothSolver: Solving for Ux, Initial residual = 0.000804391, Final residual = 2.69018e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00228908, Final residual = 3.28552e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00331322, Final residual = 0.00024979, No Iterations 4
time step continuity errors : sum local = 6.70463e-08, global = 5.45353e-09, cumulative = 4.66405e-06
GAMG: Solving for p, Initial residual = 0.000480125, Final residual = 8.70868e-07, No Iterations 16
time step continuity errors : sum local = 2.33782e-10, global = 1.58771e-11, cumulative = 4.66407e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00118617, Final residual = 4.36908e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178868, Final residual = 6.37377e-06, No Iterations 4
ExecutionTime = 21.02 s ClockTime = 21 s
Time = 2.1
Courant Number mean: 0.131601 max: 0.616743
smoothSolver: Solving for Ux, Initial residual = 0.000804138, Final residual = 2.69737e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00229159, Final residual = 3.29929e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00330905, Final residual = 0.000250574, No Iterations 4
time step continuity errors : sum local = 6.72622e-08, global = 5.46615e-09, cumulative = 4.66953e-06
GAMG: Solving for p, Initial residual = 0.000480319, Final residual = 8.61518e-07, No Iterations 16
time step continuity errors : sum local = 2.3128e-10, global = 1.56755e-11, cumulative = 4.66955e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00118799, Final residual = 4.39378e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178883, Final residual = 6.38554e-06, No Iterations 4
ExecutionTime = 21.06 s ClockTime = 21 s
Time = 2.1025
Courant Number mean: 0.13163 max: 0.616743
smoothSolver: Solving for Ux, Initial residual = 0.000803916, Final residual = 2.70447e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00229419, Final residual = 3.31267e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0033568, Final residual = 0.00025343, No Iterations 4
time step continuity errors : sum local = 6.8027e-08, global = 5.49004e-09, cumulative = 4.67504e-06
GAMG: Solving for p, Initial residual = 0.000485072, Final residual = 8.84203e-07, No Iterations 16
time step continuity errors : sum local = 2.37347e-10, global = 1.61007e-11, cumulative = 4.67506e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00118994, Final residual = 4.40776e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178891, Final residual = 6.39509e-06, No Iterations 4
ExecutionTime = 21.09 s ClockTime = 21 s
Time = 2.105
Courant Number mean: 0.131659 max: 0.616743
smoothSolver: Solving for Ux, Initial residual = 0.000803646, Final residual = 2.71173e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00229682, Final residual = 3.32611e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00323394, Final residual = 0.000256661, No Iterations 4
time step continuity errors : sum local = 6.88932e-08, global = 5.55532e-09, cumulative = 4.68061e-06
GAMG: Solving for p, Initial residual = 0.000475813, Final residual = 8.83693e-07, No Iterations 16
time step continuity errors : sum local = 2.37222e-10, global = 1.60274e-11, cumulative = 4.68063e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00119178, Final residual = 4.42459e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178901, Final residual = 6.405e-06, No Iterations 4
ExecutionTime = 21.11 s ClockTime = 21 s
Time = 2.1075
Courant Number mean: 0.131689 max: 0.616743
smoothSolver: Solving for Ux, Initial residual = 0.000803343, Final residual = 2.71923e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00229928, Final residual = 3.33893e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00319748, Final residual = 0.000255608, No Iterations 4
time step continuity errors : sum local = 6.86189e-08, global = 5.5595e-09, cumulative = 4.68619e-06
GAMG: Solving for p, Initial residual = 0.000472029, Final residual = 8.94107e-07, No Iterations 16
time step continuity errors : sum local = 2.40064e-10, global = 1.63352e-11, cumulative = 4.6862e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0011935, Final residual = 4.44629e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178912, Final residual = 6.41128e-06, No Iterations 4
ExecutionTime = 21.13 s ClockTime = 21 s
Time = 2.11
Courant Number mean: 0.131718 max: 0.616742
smoothSolver: Solving for Ux, Initial residual = 0.000803039, Final residual = 2.72676e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00230175, Final residual = 3.35148e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00332673, Final residual = 0.000252939, No Iterations 4
time step continuity errors : sum local = 6.79174e-08, global = 5.52476e-09, cumulative = 4.69173e-06
GAMG: Solving for p, Initial residual = 0.000475286, Final residual = 9.00691e-07, No Iterations 16
time step continuity errors : sum local = 2.41888e-10, global = 1.60761e-11, cumulative = 4.69174e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00119517, Final residual = 4.46087e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178922, Final residual = 6.41825e-06, No Iterations 4
ExecutionTime = 21.16 s ClockTime = 21 s
Time = 2.1125
Courant Number mean: 0.131747 max: 0.616742
smoothSolver: Solving for Ux, Initial residual = 0.000802745, Final residual = 2.73443e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00230412, Final residual = 3.36341e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00334423, Final residual = 0.000255489, No Iterations 4
time step continuity errors : sum local = 6.86172e-08, global = 5.55196e-09, cumulative = 4.6973e-06
GAMG: Solving for p, Initial residual = 0.000483859, Final residual = 8.97925e-07, No Iterations 16
time step continuity errors : sum local = 2.41195e-10, global = 1.62276e-11, cumulative = 4.69731e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00119692, Final residual = 4.48205e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017894, Final residual = 6.42542e-06, No Iterations 4
ExecutionTime = 21.18 s ClockTime = 21 s
Time = 2.115
Courant Number mean: 0.131775 max: 0.616742
smoothSolver: Solving for Ux, Initial residual = 0.00080242, Final residual = 2.74291e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00230619, Final residual = 3.37518e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0034446, Final residual = 0.000252858, No Iterations 4
time step continuity errors : sum local = 6.79154e-08, global = 5.56547e-09, cumulative = 4.70288e-06
GAMG: Solving for p, Initial residual = 0.000492592, Final residual = 5.84127e-07, No Iterations 18
time step continuity errors : sum local = 1.56896e-10, global = 1.14105e-11, cumulative = 4.70289e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00119881, Final residual = 4.4959e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178958, Final residual = 6.43167e-06, No Iterations 4
ExecutionTime = 21.21 s ClockTime = 21 s
Time = 2.1175
Courant Number mean: 0.131802 max: 0.616742
smoothSolver: Solving for Ux, Initial residual = 0.000801942, Final residual = 2.75103e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00230842, Final residual = 3.38661e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00337633, Final residual = 0.000254655, No Iterations 4
time step continuity errors : sum local = 6.83999e-08, global = 5.58988e-09, cumulative = 4.70848e-06
GAMG: Solving for p, Initial residual = 0.000493137, Final residual = 9.53165e-07, No Iterations 16
time step continuity errors : sum local = 2.56049e-10, global = 1.78522e-11, cumulative = 4.7085e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00120054, Final residual = 4.51792e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178967, Final residual = 6.4371e-06, No Iterations 4
ExecutionTime = 21.23 s ClockTime = 21 s
Time = 2.12
Courant Number mean: 0.131828 max: 0.616741
smoothSolver: Solving for Ux, Initial residual = 0.000801558, Final residual = 2.75972e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231028, Final residual = 3.39736e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00342412, Final residual = 0.000256707, No Iterations 4
time step continuity errors : sum local = 6.89705e-08, global = 5.63976e-09, cumulative = 4.71414e-06
GAMG: Solving for p, Initial residual = 0.000495126, Final residual = 9.57437e-07, No Iterations 16
time step continuity errors : sum local = 2.57315e-10, global = 1.8561e-11, cumulative = 4.71415e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00120179, Final residual = 4.53123e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178971, Final residual = 6.44716e-06, No Iterations 4
ExecutionTime = 21.25 s ClockTime = 21 s
Time = 2.1225
Courant Number mean: 0.131854 max: 0.616741
smoothSolver: Solving for Ux, Initial residual = 0.000801145, Final residual = 2.76848e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231175, Final residual = 3.40771e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00331898, Final residual = 0.000254744, No Iterations 4
time step continuity errors : sum local = 6.84554e-08, global = 5.63073e-09, cumulative = 4.71979e-06
GAMG: Solving for p, Initial residual = 0.000486115, Final residual = 9.76219e-07, No Iterations 16
time step continuity errors : sum local = 2.62333e-10, global = 1.82247e-11, cumulative = 4.7198e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00120339, Final residual = 4.54585e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017898, Final residual = 6.44962e-06, No Iterations 4
ExecutionTime = 21.28 s ClockTime = 21 s
Time = 2.125
Courant Number mean: 0.131878 max: 0.616741
smoothSolver: Solving for Ux, Initial residual = 0.000800681, Final residual = 2.77732e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231303, Final residual = 3.41795e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00317447, Final residual = 0.000255932, No Iterations 4
time step continuity errors : sum local = 6.87785e-08, global = 5.64534e-09, cumulative = 4.72545e-06
GAMG: Solving for p, Initial residual = 0.000477415, Final residual = 5.66806e-07, No Iterations 18
time step continuity errors : sum local = 1.52346e-10, global = 1.08671e-11, cumulative = 4.72546e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00120487, Final residual = 4.56219e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178985, Final residual = 6.45176e-06, No Iterations 4
ExecutionTime = 21.3 s ClockTime = 21 s
Time = 2.1275
Courant Number mean: 0.131902 max: 0.616741
smoothSolver: Solving for Ux, Initial residual = 0.00080041, Final residual = 2.78641e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231413, Final residual = 3.42807e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00317801, Final residual = 0.000254897, No Iterations 4
time step continuity errors : sum local = 6.85154e-08, global = 5.64887e-09, cumulative = 4.73111e-06
GAMG: Solving for p, Initial residual = 0.000477943, Final residual = 5.67347e-07, No Iterations 18
time step continuity errors : sum local = 1.52513e-10, global = 1.08499e-11, cumulative = 4.73112e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00120609, Final residual = 4.57655e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178994, Final residual = 6.4529e-06, No Iterations 4
ExecutionTime = 21.32 s ClockTime = 21 s
Time = 2.13
Courant Number mean: 0.131925 max: 0.61674
smoothSolver: Solving for Ux, Initial residual = 0.000800153, Final residual = 2.79508e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231523, Final residual = 3.43801e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00343817, Final residual = 0.000255419, No Iterations 4
time step continuity errors : sum local = 6.86558e-08, global = 5.66549e-09, cumulative = 4.73678e-06
GAMG: Solving for p, Initial residual = 0.000494099, Final residual = 5.98108e-07, No Iterations 18
time step continuity errors : sum local = 1.60774e-10, global = 1.17339e-11, cumulative = 4.7368e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00120718, Final residual = 4.5927e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178996, Final residual = 6.45401e-06, No Iterations 4
ExecutionTime = 21.35 s ClockTime = 21 s
Time = 2.1325
Courant Number mean: 0.131948 max: 0.61674
smoothSolver: Solving for Ux, Initial residual = 0.000799937, Final residual = 2.80362e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231627, Final residual = 3.44755e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00348361, Final residual = 0.000256481, No Iterations 4
time step continuity errors : sum local = 6.8937e-08, global = 5.71028e-09, cumulative = 4.74251e-06
GAMG: Solving for p, Initial residual = 0.000493133, Final residual = 6.03268e-07, No Iterations 18
time step continuity errors : sum local = 1.62149e-10, global = 1.19037e-11, cumulative = 4.74252e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00120837, Final residual = 4.60898e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178988, Final residual = 6.45332e-06, No Iterations 4
ExecutionTime = 21.37 s ClockTime = 22 s
Time = 2.135
Courant Number mean: 0.13197 max: 0.61674
smoothSolver: Solving for Ux, Initial residual = 0.000799672, Final residual = 2.81234e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231736, Final residual = 3.45699e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00337676, Final residual = 0.000256253, No Iterations 4
time step continuity errors : sum local = 6.88796e-08, global = 5.71274e-09, cumulative = 4.74823e-06
GAMG: Solving for p, Initial residual = 0.000487384, Final residual = 9.96401e-07, No Iterations 16
time step continuity errors : sum local = 2.6786e-10, global = 1.85364e-11, cumulative = 4.74825e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00120973, Final residual = 4.62357e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178981, Final residual = 6.4569e-06, No Iterations 4
ExecutionTime = 21.39 s ClockTime = 22 s
Time = 2.1375
Courant Number mean: 0.131993 max: 0.61674
smoothSolver: Solving for Ux, Initial residual = 0.000799458, Final residual = 2.82121e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231825, Final residual = 3.46582e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00325883, Final residual = 0.000255432, No Iterations 4
time step continuity errors : sum local = 6.86764e-08, global = 5.73897e-09, cumulative = 4.75399e-06
GAMG: Solving for p, Initial residual = 0.000482035, Final residual = 6.02887e-07, No Iterations 18
time step continuity errors : sum local = 1.62132e-10, global = 1.19393e-11, cumulative = 4.754e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00121121, Final residual = 4.6406e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017898, Final residual = 6.4558e-06, No Iterations 4
ExecutionTime = 21.42 s ClockTime = 22 s
Time = 2.14
Courant Number mean: 0.132015 max: 0.616739
smoothSolver: Solving for Ux, Initial residual = 0.000799405, Final residual = 2.83022e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231945, Final residual = 3.47443e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00349086, Final residual = 0.000253859, No Iterations 4
time step continuity errors : sum local = 6.82762e-08, global = 5.71647e-09, cumulative = 4.75972e-06
GAMG: Solving for p, Initial residual = 0.000493289, Final residual = 6.19387e-07, No Iterations 18
time step continuity errors : sum local = 1.66607e-10, global = 1.24795e-11, cumulative = 4.75973e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00121276, Final residual = 4.65555e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017899, Final residual = 6.45378e-06, No Iterations 4
ExecutionTime = 21.44 s ClockTime = 22 s
Time = 2.1425
Courant Number mean: 0.132037 max: 0.616739
smoothSolver: Solving for Ux, Initial residual = 0.000799342, Final residual = 2.83904e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00232086, Final residual = 3.48279e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00364283, Final residual = 0.0002581, No Iterations 4
time step continuity errors : sum local = 6.94228e-08, global = 5.84476e-09, cumulative = 4.76557e-06
GAMG: Solving for p, Initial residual = 0.000497888, Final residual = 6.42251e-07, No Iterations 18
time step continuity errors : sum local = 1.72755e-10, global = 1.31935e-11, cumulative = 4.76559e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00121471, Final residual = 4.67555e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178999, Final residual = 6.4506e-06, No Iterations 4
ExecutionTime = 21.46 s ClockTime = 22 s
Time = 2.145
Courant Number mean: 0.13206 max: 0.616739
smoothSolver: Solving for Ux, Initial residual = 0.000799144, Final residual = 2.84754e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00232233, Final residual = 3.49034e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00349739, Final residual = 0.000255081, No Iterations 4
time step continuity errors : sum local = 6.86138e-08, global = 5.79885e-09, cumulative = 4.77139e-06
GAMG: Solving for p, Initial residual = 0.000490989, Final residual = 6.40686e-07, No Iterations 18
time step continuity errors : sum local = 1.72353e-10, global = 1.32032e-11, cumulative = 4.7714e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00121632, Final residual = 4.6982e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00179, Final residual = 6.44661e-06, No Iterations 4
ExecutionTime = 21.48 s ClockTime = 22 s
Time = 2.1475
Courant Number mean: 0.132085 max: 0.616739
smoothSolver: Solving for Ux, Initial residual = 0.000798908, Final residual = 2.85634e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00232418, Final residual = 3.49789e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00336726, Final residual = 0.000256673, No Iterations 4
time step continuity errors : sum local = 6.90556e-08, global = 5.83739e-09, cumulative = 4.77724e-06
GAMG: Solving for p, Initial residual = 0.000487752, Final residual = 6.57969e-07, No Iterations 18
time step continuity errors : sum local = 1.77036e-10, global = 1.39213e-11, cumulative = 4.77725e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00121768, Final residual = 4.71124e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017899, Final residual = 6.44265e-06, No Iterations 4
ExecutionTime = 21.51 s ClockTime = 22 s
Time = 2.15
Courant Number mean: 0.132114 max: 0.616738
smoothSolver: Solving for Ux, Initial residual = 0.000798663, Final residual = 2.86514e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00232635, Final residual = 3.50485e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00323914, Final residual = 0.000257148, No Iterations 4
time step continuity errors : sum local = 6.91952e-08, global = 5.87179e-09, cumulative = 4.78312e-06
GAMG: Solving for p, Initial residual = 0.000479157, Final residual = 6.67825e-07, No Iterations 18
time step continuity errors : sum local = 1.79722e-10, global = 1.41402e-11, cumulative = 4.78314e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00121933, Final residual = 4.7302e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178972, Final residual = 6.438e-06, No Iterations 4
ExecutionTime = 21.53 s ClockTime = 22 s
Time = 2.1525
Courant Number mean: 0.132144 max: 0.616738
smoothSolver: Solving for Ux, Initial residual = 0.000798481, Final residual = 2.87427e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00232869, Final residual = 3.51165e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00330963, Final residual = 0.000258303, No Iterations 4
time step continuity errors : sum local = 6.95233e-08, global = 5.9113e-09, cumulative = 4.78905e-06
GAMG: Solving for p, Initial residual = 0.000473936, Final residual = 6.70719e-07, No Iterations 18
time step continuity errors : sum local = 1.80544e-10, global = 1.41748e-11, cumulative = 4.78906e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00122103, Final residual = 4.74308e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178964, Final residual = 6.43489e-06, No Iterations 4
ExecutionTime = 21.56 s ClockTime = 22 s
Time = 2.155
Courant Number mean: 0.132174 max: 0.616738
smoothSolver: Solving for Ux, Initial residual = 0.000798285, Final residual = 2.88322e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023311, Final residual = 3.51751e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00340525, Final residual = 0.000260888, No Iterations 4
time step continuity errors : sum local = 7.02319e-08, global = 5.99552e-09, cumulative = 4.79506e-06
GAMG: Solving for p, Initial residual = 0.000485072, Final residual = 6.95434e-07, No Iterations 18
time step continuity errors : sum local = 1.87225e-10, global = 1.49303e-11, cumulative = 4.79507e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00122267, Final residual = 4.75576e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178955, Final residual = 6.42803e-06, No Iterations 4
ExecutionTime = 21.58 s ClockTime = 22 s
Time = 2.1575
Courant Number mean: 0.132204 max: 0.616738
smoothSolver: Solving for Ux, Initial residual = 0.000798062, Final residual = 2.8919e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00233357, Final residual = 3.52272e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00352181, Final residual = 0.000259338, No Iterations 4
time step continuity errors : sum local = 6.98272e-08, global = 5.99121e-09, cumulative = 4.80106e-06
GAMG: Solving for p, Initial residual = 0.000490822, Final residual = 7.28261e-07, No Iterations 18
time step continuity errors : sum local = 1.96104e-10, global = 1.64406e-11, cumulative = 4.80108e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00122421, Final residual = 4.76886e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178933, Final residual = 6.42824e-06, No Iterations 4
ExecutionTime = 21.6 s ClockTime = 22 s
Time = 2.16
Courant Number mean: 0.132234 max: 0.616737
smoothSolver: Solving for Ux, Initial residual = 0.000797765, Final residual = 2.90052e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00233599, Final residual = 3.52789e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00348024, Final residual = 0.000260667, No Iterations 4
time step continuity errors : sum local = 7.01879e-08, global = 6.0181e-09, cumulative = 4.8071e-06
GAMG: Solving for p, Initial residual = 0.000496212, Final residual = 7.28124e-07, No Iterations 18
time step continuity errors : sum local = 1.96044e-10, global = 1.66315e-11, cumulative = 4.80712e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00122564, Final residual = 4.78228e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178912, Final residual = 6.42034e-06, No Iterations 4
ExecutionTime = 21.63 s ClockTime = 22 s
Time = 2.1625
Courant Number mean: 0.132262 max: 0.616737
smoothSolver: Solving for Ux, Initial residual = 0.000797374, Final residual = 2.90901e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00233829, Final residual = 3.53253e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00347496, Final residual = 0.000262752, No Iterations 4
time step continuity errors : sum local = 7.0748e-08, global = 6.04437e-09, cumulative = 4.81316e-06
GAMG: Solving for p, Initial residual = 0.000499587, Final residual = 7.29314e-07, No Iterations 18
time step continuity errors : sum local = 1.96379e-10, global = 1.66171e-11, cumulative = 4.81318e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00122718, Final residual = 4.7949e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017889, Final residual = 6.41232e-06, No Iterations 4
ExecutionTime = 21.66 s ClockTime = 22 s
Time = 2.165
Courant Number mean: 0.13229 max: 0.616737
smoothSolver: Solving for Ux, Initial residual = 0.000796979, Final residual = 2.9175e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234065, Final residual = 3.53675e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00369197, Final residual = 0.000262839, No Iterations 4
time step continuity errors : sum local = 7.07801e-08, global = 6.06318e-09, cumulative = 4.81924e-06
GAMG: Solving for p, Initial residual = 0.000521638, Final residual = 7.09368e-07, No Iterations 18
time step continuity errors : sum local = 1.91041e-10, global = 1.56775e-11, cumulative = 4.81926e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00122885, Final residual = 4.80928e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178862, Final residual = 6.40359e-06, No Iterations 4
ExecutionTime = 21.69 s ClockTime = 22 s
Time = 2.1675
Courant Number mean: 0.132317 max: 0.616736
smoothSolver: Solving for Ux, Initial residual = 0.000796593, Final residual = 2.92597e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234272, Final residual = 3.5404e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00371595, Final residual = 0.000263026, No Iterations 4
time step continuity errors : sum local = 7.08504e-08, global = 6.08523e-09, cumulative = 4.82534e-06
GAMG: Solving for p, Initial residual = 0.000527155, Final residual = 7.10858e-07, No Iterations 18
time step continuity errors : sum local = 1.91506e-10, global = 1.59136e-11, cumulative = 4.82536e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00123041, Final residual = 4.81645e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178819, Final residual = 6.39959e-06, No Iterations 4
ExecutionTime = 21.71 s ClockTime = 22 s
Time = 2.17
Courant Number mean: 0.132342 max: 0.616736
smoothSolver: Solving for Ux, Initial residual = 0.000796221, Final residual = 2.93483e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234459, Final residual = 3.54345e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00348276, Final residual = 0.000262105, No Iterations 4
time step continuity errors : sum local = 7.06279e-08, global = 6.07713e-09, cumulative = 4.83143e-06
GAMG: Solving for p, Initial residual = 0.000504067, Final residual = 7.3294e-07, No Iterations 18
time step continuity errors : sum local = 1.97544e-10, global = 1.74181e-11, cumulative = 4.83145e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00123174, Final residual = 4.83365e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178788, Final residual = 6.39046e-06, No Iterations 4
ExecutionTime = 21.73 s ClockTime = 22 s
Time = 2.1725
Courant Number mean: 0.132367 max: 0.616736
smoothSolver: Solving for Ux, Initial residual = 0.000795802, Final residual = 2.94351e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234599, Final residual = 3.54598e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00347399, Final residual = 0.000262331, No Iterations 4
time step continuity errors : sum local = 7.07221e-08, global = 6.082e-09, cumulative = 4.83753e-06
GAMG: Solving for p, Initial residual = 0.000506428, Final residual = 7.31951e-07, No Iterations 18
time step continuity errors : sum local = 1.97376e-10, global = 1.74656e-11, cumulative = 4.83755e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012331, Final residual = 4.84785e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178755, Final residual = 6.38632e-06, No Iterations 4
ExecutionTime = 21.76 s ClockTime = 22 s
Time = 2.175
Courant Number mean: 0.132391 max: 0.616736
smoothSolver: Solving for Ux, Initial residual = 0.000795393, Final residual = 2.95214e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234703, Final residual = 3.54809e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00359468, Final residual = 0.000263569, No Iterations 4
time step continuity errors : sum local = 7.11005e-08, global = 6.11316e-09, cumulative = 4.84366e-06
GAMG: Solving for p, Initial residual = 0.000509857, Final residual = 7.45029e-07, No Iterations 18
time step continuity errors : sum local = 2.01059e-10, global = 1.85663e-11, cumulative = 4.84368e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00123449, Final residual = 4.86066e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178733, Final residual = 6.37571e-06, No Iterations 4
ExecutionTime = 21.79 s ClockTime = 22 s
Time = 2.1775
Courant Number mean: 0.132414 max: 0.616735
smoothSolver: Solving for Ux, Initial residual = 0.000794966, Final residual = 2.96067e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234793, Final residual = 3.54997e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00351499, Final residual = 0.000266606, No Iterations 4
time step continuity errors : sum local = 7.19481e-08, global = 6.1984e-09, cumulative = 4.84988e-06
GAMG: Solving for p, Initial residual = 0.00049713, Final residual = 7.36755e-07, No Iterations 18
time step continuity errors : sum local = 1.98823e-10, global = 1.71486e-11, cumulative = 4.8499e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012363, Final residual = 4.873e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017872, Final residual = 6.36556e-06, No Iterations 4
ExecutionTime = 21.81 s ClockTime = 22 s
Time = 2.18
Courant Number mean: 0.132436 max: 0.616735
smoothSolver: Solving for Ux, Initial residual = 0.000794651, Final residual = 2.96931e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023488, Final residual = 3.55141e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00337889, Final residual = 0.00026853, No Iterations 4
time step continuity errors : sum local = 7.24687e-08, global = 6.23063e-09, cumulative = 4.85613e-06
GAMG: Solving for p, Initial residual = 0.000491248, Final residual = 7.37409e-07, No Iterations 18
time step continuity errors : sum local = 1.99021e-10, global = 1.74971e-11, cumulative = 4.85615e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00123794, Final residual = 4.89159e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178717, Final residual = 6.35455e-06, No Iterations 4
ExecutionTime = 21.84 s ClockTime = 22 s
Time = 2.1825
Courant Number mean: 0.132457 max: 0.616735
smoothSolver: Solving for Ux, Initial residual = 0.000794442, Final residual = 2.97768e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234981, Final residual = 3.553e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00357218, Final residual = 0.000269369, No Iterations 4
time step continuity errors : sum local = 7.27113e-08, global = 6.2262e-09, cumulative = 4.86237e-06
GAMG: Solving for p, Initial residual = 0.000506843, Final residual = 7.14469e-07, No Iterations 18
time step continuity errors : sum local = 1.92885e-10, global = 1.64443e-11, cumulative = 4.86239e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00123947, Final residual = 4.90289e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178679, Final residual = 6.34296e-06, No Iterations 4
ExecutionTime = 21.86 s ClockTime = 22 s
Time = 2.185
Courant Number mean: 0.132478 max: 0.616735
smoothSolver: Solving for Ux, Initial residual = 0.000794507, Final residual = 2.98594e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235059, Final residual = 3.55429e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00362825, Final residual = 0.000269351, No Iterations 4
time step continuity errors : sum local = 7.27123e-08, global = 6.26383e-09, cumulative = 4.86865e-06
GAMG: Solving for p, Initial residual = 0.000507004, Final residual = 7.37696e-07, No Iterations 18
time step continuity errors : sum local = 1.99135e-10, global = 1.75667e-11, cumulative = 4.86867e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012411, Final residual = 4.9113e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178646, Final residual = 6.33371e-06, No Iterations 4
ExecutionTime = 21.89 s ClockTime = 22 s
Time = 2.1875
Courant Number mean: 0.132497 max: 0.616734
smoothSolver: Solving for Ux, Initial residual = 0.00079454, Final residual = 2.99362e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235144, Final residual = 3.5554e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00372504, Final residual = 0.000271286, No Iterations 4
time step continuity errors : sum local = 7.32334e-08, global = 6.28565e-09, cumulative = 4.87496e-06
GAMG: Solving for p, Initial residual = 0.000516785, Final residual = 7.17721e-07, No Iterations 18
time step continuity errors : sum local = 1.93742e-10, global = 1.75265e-11, cumulative = 4.87497e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00124282, Final residual = 4.92256e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178641, Final residual = 6.3213e-06, No Iterations 4
ExecutionTime = 21.91 s ClockTime = 22 s
Time = 2.19
Courant Number mean: 0.132516 max: 0.616734
smoothSolver: Solving for Ux, Initial residual = 0.000794586, Final residual = 3.00116e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235217, Final residual = 3.55632e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0036972, Final residual = 0.000273879, No Iterations 4
time step continuity errors : sum local = 7.39346e-08, global = 6.34971e-09, cumulative = 4.88132e-06
GAMG: Solving for p, Initial residual = 0.000511886, Final residual = 7.09178e-07, No Iterations 18
time step continuity errors : sum local = 1.91448e-10, global = 1.61925e-11, cumulative = 4.88134e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00124461, Final residual = 4.93472e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017863, Final residual = 6.30838e-06, No Iterations 4
ExecutionTime = 21.94 s ClockTime = 22 s
Time = 2.1925
Courant Number mean: 0.132535 max: 0.616734
smoothSolver: Solving for Ux, Initial residual = 0.000794445, Final residual = 3.00864e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235332, Final residual = 3.55677e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00337436, Final residual = 0.000274862, No Iterations 4
time step continuity errors : sum local = 7.42019e-08, global = 6.37045e-09, cumulative = 4.88771e-06
GAMG: Solving for p, Initial residual = 0.000495743, Final residual = 7.27808e-07, No Iterations 18
time step continuity errors : sum local = 1.96481e-10, global = 1.76823e-11, cumulative = 4.88773e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00124623, Final residual = 4.95344e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178604, Final residual = 6.2967e-06, No Iterations 4
ExecutionTime = 21.96 s ClockTime = 22 s
Time = 2.195
Courant Number mean: 0.132555 max: 0.616734
smoothSolver: Solving for Ux, Initial residual = 0.000794352, Final residual = 3.01599e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235465, Final residual = 3.55711e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00349335, Final residual = 0.000277599, No Iterations 4
time step continuity errors : sum local = 7.4937e-08, global = 6.41799e-09, cumulative = 4.89415e-06
GAMG: Solving for p, Initial residual = 0.000504122, Final residual = 7.57711e-07, No Iterations 18
time step continuity errors : sum local = 2.04532e-10, global = 1.91405e-11, cumulative = 4.89416e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00124766, Final residual = 4.96449e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178573, Final residual = 6.28509e-06, No Iterations 4
ExecutionTime = 21.99 s ClockTime = 22 s
Time = 2.1975
Courant Number mean: 0.132579 max: 0.616733
smoothSolver: Solving for Ux, Initial residual = 0.000794186, Final residual = 3.02307e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235605, Final residual = 3.55718e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00355512, Final residual = 0.000277829, No Iterations 4
time step continuity errors : sum local = 7.49905e-08, global = 6.41707e-09, cumulative = 4.90058e-06
GAMG: Solving for p, Initial residual = 0.000507566, Final residual = 6.61969e-07, No Iterations 18
time step continuity errors : sum local = 1.78665e-10, global = 1.44978e-11, cumulative = 4.9006e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00124885, Final residual = 4.9754e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178529, Final residual = 6.27737e-06, No Iterations 4
ExecutionTime = 22.01 s ClockTime = 22 s
Time = 2.2
Courant Number mean: 0.132607 max: 0.616733
smoothSolver: Solving for Ux, Initial residual = 0.000794096, Final residual = 3.03029e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235717, Final residual = 3.55662e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00353703, Final residual = 0.000279242, No Iterations 4
time step continuity errors : sum local = 7.53761e-08, global = 6.4354e-09, cumulative = 4.90703e-06
GAMG: Solving for p, Initial residual = 0.000511156, Final residual = 7.17987e-07, No Iterations 18
time step continuity errors : sum local = 1.93815e-10, global = 1.73994e-11, cumulative = 4.90705e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125024, Final residual = 4.98596e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178496, Final residual = 6.2642e-06, No Iterations 4
ExecutionTime = 22.06 s ClockTime = 22 s
Time = 2.2025
Courant Number mean: 0.132635 max: 0.616733
smoothSolver: Solving for Ux, Initial residual = 0.000794006, Final residual = 3.03679e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235901, Final residual = 3.55619e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00386928, Final residual = 0.000276995, No Iterations 4
time step continuity errors : sum local = 7.47763e-08, global = 6.38751e-09, cumulative = 4.91344e-06
GAMG: Solving for p, Initial residual = 0.000518288, Final residual = 7.19305e-07, No Iterations 18
time step continuity errors : sum local = 1.94166e-10, global = 1.81917e-11, cumulative = 4.91345e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125152, Final residual = 4.99745e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178473, Final residual = 6.25137e-06, No Iterations 4
ExecutionTime = 22.09 s ClockTime = 22 s
Time = 2.205
Courant Number mean: 0.132663 max: 0.616733
smoothSolver: Solving for Ux, Initial residual = 0.00079377, Final residual = 3.04286e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023614, Final residual = 3.55527e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00375609, Final residual = 0.000279744, No Iterations 4
time step continuity errors : sum local = 7.55241e-08, global = 6.46064e-09, cumulative = 4.91991e-06
GAMG: Solving for p, Initial residual = 0.000510176, Final residual = 7.05188e-07, No Iterations 18
time step continuity errors : sum local = 1.90382e-10, global = 1.73069e-11, cumulative = 4.91993e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125277, Final residual = 5.00989e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017843, Final residual = 6.23836e-06, No Iterations 4
ExecutionTime = 22.11 s ClockTime = 22 s
Time = 2.2075
Courant Number mean: 0.13269 max: 0.616732
smoothSolver: Solving for Ux, Initial residual = 0.000793419, Final residual = 3.04926e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00236368, Final residual = 3.5536e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00351432, Final residual = 0.000283144, No Iterations 4
time step continuity errors : sum local = 7.64472e-08, global = 6.52283e-09, cumulative = 4.92646e-06
GAMG: Solving for p, Initial residual = 0.000505401, Final residual = 6.89078e-07, No Iterations 18
time step continuity errors : sum local = 1.8604e-10, global = 1.63063e-11, cumulative = 4.92647e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125405, Final residual = 5.02266e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178381, Final residual = 6.22494e-06, No Iterations 4
ExecutionTime = 22.13 s ClockTime = 22 s
Time = 2.21
Courant Number mean: 0.132716 max: 0.616732
smoothSolver: Solving for Ux, Initial residual = 0.00079303, Final residual = 3.0556e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00236585, Final residual = 3.5515e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00346686, Final residual = 0.000281666, No Iterations 4
time step continuity errors : sum local = 7.60512e-08, global = 6.52392e-09, cumulative = 4.933e-06
GAMG: Solving for p, Initial residual = 0.000503044, Final residual = 6.92935e-07, No Iterations 18
time step continuity errors : sum local = 1.87085e-10, global = 1.65992e-11, cumulative = 4.93301e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125553, Final residual = 5.03361e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178325, Final residual = 6.21178e-06, No Iterations 4
ExecutionTime = 22.16 s ClockTime = 22 s
Time = 2.2125
Courant Number mean: 0.132742 max: 0.616732
smoothSolver: Solving for Ux, Initial residual = 0.000792591, Final residual = 3.06174e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00236806, Final residual = 3.54922e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00350326, Final residual = 0.00028392, No Iterations 4
time step continuity errors : sum local = 7.66683e-08, global = 6.55249e-09, cumulative = 4.93956e-06
GAMG: Solving for p, Initial residual = 0.000516169, Final residual = 6.89292e-07, No Iterations 18
time step continuity errors : sum local = 1.86138e-10, global = 1.62414e-11, cumulative = 4.93958e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125682, Final residual = 5.05211e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178266, Final residual = 6.20106e-06, No Iterations 4
ExecutionTime = 22.18 s ClockTime = 22 s
Time = 2.215
Courant Number mean: 0.132766 max: 0.616732
smoothSolver: Solving for Ux, Initial residual = 0.00079213, Final residual = 3.06807e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237013, Final residual = 3.54651e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00360206, Final residual = 0.000286429, No Iterations 4
time step continuity errors : sum local = 7.73635e-08, global = 6.615e-09, cumulative = 4.9462e-06
GAMG: Solving for p, Initial residual = 0.000530032, Final residual = 7.36001e-07, No Iterations 18
time step continuity errors : sum local = 1.98811e-10, global = 1.88217e-11, cumulative = 4.94621e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125822, Final residual = 5.0624e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178214, Final residual = 6.18672e-06, No Iterations 4
ExecutionTime = 22.21 s ClockTime = 22 s
Time = 2.2175
Courant Number mean: 0.132789 max: 0.616731
smoothSolver: Solving for Ux, Initial residual = 0.000791753, Final residual = 3.07368e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237204, Final residual = 3.54349e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00364779, Final residual = 0.000287271, No Iterations 4
time step continuity errors : sum local = 7.76101e-08, global = 6.63728e-09, cumulative = 4.95285e-06
GAMG: Solving for p, Initial residual = 0.000533192, Final residual = 6.92706e-07, No Iterations 18
time step continuity errors : sum local = 1.87154e-10, global = 1.63958e-11, cumulative = 4.95287e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125978, Final residual = 5.07163e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178142, Final residual = 6.17149e-06, No Iterations 4
ExecutionTime = 22.24 s ClockTime = 22 s
Time = 2.22
Courant Number mean: 0.132811 max: 0.616731
smoothSolver: Solving for Ux, Initial residual = 0.000791372, Final residual = 3.07985e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023734, Final residual = 3.53982e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00353554, Final residual = 0.000288642, No Iterations 4
time step continuity errors : sum local = 7.80025e-08, global = 6.68967e-09, cumulative = 4.95956e-06
GAMG: Solving for p, Initial residual = 0.000526957, Final residual = 7.1508e-07, No Iterations 18
time step continuity errors : sum local = 1.93271e-10, global = 1.74864e-11, cumulative = 4.95958e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00126126, Final residual = 5.08084e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178073, Final residual = 6.15778e-06, No Iterations 4
ExecutionTime = 22.27 s ClockTime = 22 s
Time = 2.2225
Courant Number mean: 0.132832 max: 0.616731
smoothSolver: Solving for Ux, Initial residual = 0.000790897, Final residual = 3.08552e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237442, Final residual = 3.53575e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0034946, Final residual = 0.000289059, No Iterations 4
time step continuity errors : sum local = 7.81539e-08, global = 6.67056e-09, cumulative = 4.96625e-06
GAMG: Solving for p, Initial residual = 0.000525494, Final residual = 6.85777e-07, No Iterations 18
time step continuity errors : sum local = 1.85453e-10, global = 1.60842e-11, cumulative = 4.96626e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00126273, Final residual = 5.09078e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00178017, Final residual = 6.14394e-06, No Iterations 4
ExecutionTime = 22.29 s ClockTime = 22 s
Time = 2.225
Courant Number mean: 0.132852 max: 0.616731
smoothSolver: Solving for Ux, Initial residual = 0.000790412, Final residual = 3.09108e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237517, Final residual = 3.53124e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00340061, Final residual = 0.000290688, No Iterations 4
time step continuity errors : sum local = 7.86365e-08, global = 6.76605e-09, cumulative = 4.97303e-06
GAMG: Solving for p, Initial residual = 0.000516957, Final residual = 7.29503e-07, No Iterations 18
time step continuity errors : sum local = 1.97396e-10, global = 1.8172e-11, cumulative = 4.97305e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00126412, Final residual = 5.10149e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177973, Final residual = 6.12947e-06, No Iterations 4
ExecutionTime = 22.32 s ClockTime = 22 s
Time = 2.2275
Courant Number mean: 0.132871 max: 0.61673
smoothSolver: Solving for Ux, Initial residual = 0.000790089, Final residual = 3.09683e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237587, Final residual = 3.52634e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0036261, Final residual = 0.000290465, No Iterations 4
time step continuity errors : sum local = 7.86205e-08, global = 6.78299e-09, cumulative = 4.97983e-06
GAMG: Solving for p, Initial residual = 0.000518088, Final residual = 8.0382e-07, No Iterations 18
time step continuity errors : sum local = 2.17617e-10, global = 2.34067e-11, cumulative = 4.97985e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012657, Final residual = 5.11255e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017794, Final residual = 6.11669e-06, No Iterations 4
ExecutionTime = 22.35 s ClockTime = 22 s
Time = 2.23
Courant Number mean: 0.13289 max: 0.61673
smoothSolver: Solving for Ux, Initial residual = 0.000789922, Final residual = 3.10201e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237658, Final residual = 3.52156e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00383202, Final residual = 0.000289342, No Iterations 4
time step continuity errors : sum local = 7.83276e-08, global = 6.78674e-09, cumulative = 4.98664e-06
GAMG: Solving for p, Initial residual = 0.00053644, Final residual = 7.45317e-07, No Iterations 18
time step continuity errors : sum local = 2.01735e-10, global = 1.90152e-11, cumulative = 4.98666e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00126711, Final residual = 5.123e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177904, Final residual = 6.10202e-06, No Iterations 4
ExecutionTime = 22.37 s ClockTime = 23 s
Time = 2.2325
Courant Number mean: 0.132909 max: 0.61673
smoothSolver: Solving for Ux, Initial residual = 0.000789981, Final residual = 3.10724e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237701, Final residual = 3.51627e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00389395, Final residual = 0.00028858, No Iterations 4
time step continuity errors : sum local = 7.81149e-08, global = 6.78467e-09, cumulative = 4.99344e-06
GAMG: Solving for p, Initial residual = 0.000541019, Final residual = 8.12686e-07, No Iterations 18
time step continuity errors : sum local = 2.19979e-10, global = 2.45027e-11, cumulative = 4.99347e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012686, Final residual = 5.13507e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177848, Final residual = 6.08808e-06, No Iterations 4
ExecutionTime = 22.39 s ClockTime = 23 s
Time = 2.235
Courant Number mean: 0.132926 max: 0.61673
smoothSolver: Solving for Ux, Initial residual = 0.000790084, Final residual = 3.11163e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237765, Final residual = 3.51167e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00380849, Final residual = 0.000289992, No Iterations 4
time step continuity errors : sum local = 7.85099e-08, global = 6.81697e-09, cumulative = 5.00028e-06
GAMG: Solving for p, Initial residual = 0.000536216, Final residual = 7.41164e-07, No Iterations 18
time step continuity errors : sum local = 2.00656e-10, global = 1.94997e-11, cumulative = 5.0003e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012701, Final residual = 5.14676e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177802, Final residual = 6.07271e-06, No Iterations 4
ExecutionTime = 22.41 s ClockTime = 23 s
Time = 2.2375
Courant Number mean: 0.132943 max: 0.616729
smoothSolver: Solving for Ux, Initial residual = 0.000790119, Final residual = 3.11601e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237813, Final residual = 3.50681e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0036993, Final residual = 0.000290081, No Iterations 4
time step continuity errors : sum local = 7.8544e-08, global = 6.84289e-09, cumulative = 5.00715e-06
GAMG: Solving for p, Initial residual = 0.000517647, Final residual = 7.68713e-07, No Iterations 18
time step continuity errors : sum local = 2.08137e-10, global = 2.08041e-11, cumulative = 5.00717e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00127165, Final residual = 5.16415e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177763, Final residual = 6.05677e-06, No Iterations 4
ExecutionTime = 22.44 s ClockTime = 23 s
Time = 2.24
Courant Number mean: 0.13296 max: 0.616729
smoothSolver: Solving for Ux, Initial residual = 0.000790166, Final residual = 3.12008e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237836, Final residual = 3.50236e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00378595, Final residual = 0.000291841, No Iterations 4
time step continuity errors : sum local = 7.90292e-08, global = 6.87519e-09, cumulative = 5.01404e-06
GAMG: Solving for p, Initial residual = 0.000532472, Final residual = 7.94109e-07, No Iterations 18
time step continuity errors : sum local = 2.15042e-10, global = 2.20128e-11, cumulative = 5.01406e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00127313, Final residual = 5.17675e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177706, Final residual = 6.03989e-06, No Iterations 4
ExecutionTime = 22.46 s ClockTime = 23 s
Time = 2.2425
Courant Number mean: 0.132976 max: 0.616729
smoothSolver: Solving for Ux, Initial residual = 0.000790153, Final residual = 3.12396e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237873, Final residual = 3.4977e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00369587, Final residual = 0.0002926, No Iterations 4
time step continuity errors : sum local = 7.9251e-08, global = 6.88622e-09, cumulative = 5.02095e-06
GAMG: Solving for p, Initial residual = 0.000522623, Final residual = 7.79031e-07, No Iterations 18
time step continuity errors : sum local = 2.11009e-10, global = 2.06593e-11, cumulative = 5.02097e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00127469, Final residual = 5.18703e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177645, Final residual = 6.02329e-06, No Iterations 4
ExecutionTime = 22.49 s ClockTime = 23 s
Time = 2.245
Courant Number mean: 0.132996 max: 0.616729
smoothSolver: Solving for Ux, Initial residual = 0.000790111, Final residual = 3.12774e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237931, Final residual = 3.49316e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00364153, Final residual = 0.000291125, No Iterations 4
time step continuity errors : sum local = 7.88641e-08, global = 6.91145e-09, cumulative = 5.02788e-06
GAMG: Solving for p, Initial residual = 0.000522644, Final residual = 8.17975e-07, No Iterations 18
time step continuity errors : sum local = 2.21572e-10, global = 2.34507e-11, cumulative = 5.02791e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00127611, Final residual = 5.20312e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017759, Final residual = 6.00679e-06, No Iterations 4
ExecutionTime = 22.51 s ClockTime = 23 s
Time = 2.2475
Courant Number mean: 0.133024 max: 0.616729
smoothSolver: Solving for Ux, Initial residual = 0.000790015, Final residual = 3.1312e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237997, Final residual = 3.48866e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00367988, Final residual = 0.000294171, No Iterations 4
time step continuity errors : sum local = 7.96966e-08, global = 6.99417e-09, cumulative = 5.0349e-06
GAMG: Solving for p, Initial residual = 0.000535921, Final residual = 8.27099e-07, No Iterations 18
time step continuity errors : sum local = 2.2406e-10, global = 2.37796e-11, cumulative = 5.03492e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00127741, Final residual = 5.21239e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177533, Final residual = 5.98848e-06, No Iterations 4
ExecutionTime = 22.54 s ClockTime = 23 s
Time = 2.25
Courant Number mean: 0.133053 max: 0.616728
smoothSolver: Solving for Ux, Initial residual = 0.000790015, Final residual = 3.13474e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238053, Final residual = 3.48438e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00363395, Final residual = 0.00031742, No Iterations 4
time step continuity errors : sum local = 8.60104e-08, global = 7.84045e-09, cumulative = 5.04277e-06
GAMG: Solving for p, Initial residual = 0.000528917, Final residual = 8.23715e-07, No Iterations 18
time step continuity errors : sum local = 2.232e-10, global = 2.21785e-11, cumulative = 5.04279e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00127901, Final residual = 5.22325e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177479, Final residual = 5.97054e-06, No Iterations 4
ExecutionTime = 22.56 s ClockTime = 23 s
Time = 2.2525
Courant Number mean: 0.133081 max: 0.616728
smoothSolver: Solving for Ux, Initial residual = 0.000789853, Final residual = 3.13764e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238159, Final residual = 3.48126e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00371526, Final residual = 0.000315338, No Iterations 4
time step continuity errors : sum local = 8.5487e-08, global = 7.8368e-09, cumulative = 5.05062e-06
GAMG: Solving for p, Initial residual = 0.000524289, Final residual = 7.99357e-07, No Iterations 18
time step continuity errors : sum local = 2.16732e-10, global = 2.07043e-11, cumulative = 5.05064e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128033, Final residual = 5.22766e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177416, Final residual = 5.95177e-06, No Iterations 4
ExecutionTime = 22.59 s ClockTime = 23 s
Time = 2.255
Courant Number mean: 0.133108 max: 0.616728
smoothSolver: Solving for Ux, Initial residual = 0.000789579, Final residual = 3.14074e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238294, Final residual = 3.47782e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00377473, Final residual = 0.000317819, No Iterations 4
time step continuity errors : sum local = 8.61877e-08, global = 7.87821e-09, cumulative = 5.05852e-06
GAMG: Solving for p, Initial residual = 0.000535075, Final residual = 7.71823e-07, No Iterations 18
time step continuity errors : sum local = 2.09277e-10, global = 1.92333e-11, cumulative = 5.05854e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012816, Final residual = 5.23823e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177334, Final residual = 5.93275e-06, No Iterations 4
ExecutionTime = 22.61 s ClockTime = 23 s
Time = 2.2575
Courant Number mean: 0.133135 max: 0.616728
smoothSolver: Solving for Ux, Initial residual = 0.000789285, Final residual = 3.14399e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238466, Final residual = 3.47425e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00364811, Final residual = 0.00031833, No Iterations 4
time step continuity errors : sum local = 8.63449e-08, global = 7.89119e-09, cumulative = 5.06643e-06
GAMG: Solving for p, Initial residual = 0.000535748, Final residual = 7.29893e-07, No Iterations 18
time step continuity errors : sum local = 1.97994e-10, global = 1.71628e-11, cumulative = 5.06645e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128289, Final residual = 5.24907e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177255, Final residual = 5.91463e-06, No Iterations 4
ExecutionTime = 22.63 s ClockTime = 23 s
Time = 2.26
Courant Number mean: 0.133159 max: 0.616728
smoothSolver: Solving for Ux, Initial residual = 0.000788822, Final residual = 3.14707e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238658, Final residual = 3.47083e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00342806, Final residual = 0.000318052, No Iterations 4
time step continuity errors : sum local = 8.63079e-08, global = 7.90261e-09, cumulative = 5.07435e-06
GAMG: Solving for p, Initial residual = 0.000524133, Final residual = 6.87893e-07, No Iterations 18
time step continuity errors : sum local = 1.86693e-10, global = 1.54366e-11, cumulative = 5.07437e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128403, Final residual = 5.25904e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177178, Final residual = 5.90048e-06, No Iterations 4
ExecutionTime = 22.66 s ClockTime = 23 s
Time = 2.2625
Courant Number mean: 0.133183 max: 0.616727
smoothSolver: Solving for Ux, Initial residual = 0.000788411, Final residual = 3.1504e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023883, Final residual = 3.46735e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00344174, Final residual = 0.000317285, No Iterations 4
time step continuity errors : sum local = 8.61304e-08, global = 7.90084e-09, cumulative = 5.08227e-06
GAMG: Solving for p, Initial residual = 0.000529387, Final residual = 6.61556e-07, No Iterations 18
time step continuity errors : sum local = 1.7959e-10, global = 1.4403e-11, cumulative = 5.08228e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128551, Final residual = 5.27059e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177103, Final residual = 5.88065e-06, No Iterations 4
ExecutionTime = 22.7 s ClockTime = 23 s
Time = 2.265
Courant Number mean: 0.133205 max: 0.616727
smoothSolver: Solving for Ux, Initial residual = 0.000787934, Final residual = 3.15368e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239, Final residual = 3.46416e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00352639, Final residual = 0.000318521, No Iterations 4
time step continuity errors : sum local = 8.64872e-08, global = 7.92521e-09, cumulative = 5.09021e-06
GAMG: Solving for p, Initial residual = 0.000536486, Final residual = 6.35571e-07, No Iterations 18
time step continuity errors : sum local = 1.72579e-10, global = 1.34963e-11, cumulative = 5.09022e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128685, Final residual = 5.28064e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00177013, Final residual = 5.86156e-06, No Iterations 4
ExecutionTime = 22.72 s ClockTime = 23 s
Time = 2.2675
Courant Number mean: 0.133226 max: 0.616727
smoothSolver: Solving for Ux, Initial residual = 0.000787428, Final residual = 3.1569e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239135, Final residual = 3.46088e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00368107, Final residual = 0.000320249, No Iterations 4
time step continuity errors : sum local = 8.6979e-08, global = 7.96855e-09, cumulative = 5.09819e-06
GAMG: Solving for p, Initial residual = 0.000550454, Final residual = 6.10259e-07, No Iterations 18
time step continuity errors : sum local = 1.65751e-10, global = 1.2687e-11, cumulative = 5.0982e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128782, Final residual = 5.29615e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176913, Final residual = 5.84163e-06, No Iterations 4
ExecutionTime = 22.74 s ClockTime = 23 s
Time = 2.27
Courant Number mean: 0.133245 max: 0.616727
smoothSolver: Solving for Ux, Initial residual = 0.000786908, Final residual = 3.1601e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239222, Final residual = 3.45733e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00366372, Final residual = 0.000319694, No Iterations 4
time step continuity errors : sum local = 8.68583e-08, global = 7.94631e-09, cumulative = 5.10615e-06
GAMG: Solving for p, Initial residual = 0.000546576, Final residual = 6.32723e-07, No Iterations 18
time step continuity errors : sum local = 1.71925e-10, global = 1.35569e-11, cumulative = 5.10616e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128878, Final residual = 5.30812e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176838, Final residual = 5.82114e-06, No Iterations 4
ExecutionTime = 22.77 s ClockTime = 23 s
Time = 2.2725
Courant Number mean: 0.133264 max: 0.616727
smoothSolver: Solving for Ux, Initial residual = 0.000786527, Final residual = 3.16285e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239334, Final residual = 3.45459e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00369505, Final residual = 0.000322767, No Iterations 4
time step continuity errors : sum local = 8.77368e-08, global = 8.12862e-09, cumulative = 5.11429e-06
GAMG: Solving for p, Initial residual = 0.000550797, Final residual = 9.42991e-07, No Iterations 19
time step continuity errors : sum local = 2.56339e-10, global = -5.01083e-11, cumulative = 5.11424e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128987, Final residual = 5.31958e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176767, Final residual = 5.80084e-06, No Iterations 4
ExecutionTime = 22.8 s ClockTime = 23 s
Time = 2.275
Courant Number mean: 0.133281 max: 0.616726
smoothSolver: Solving for Ux, Initial residual = 0.000786241, Final residual = 3.16588e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.002394, Final residual = 3.45129e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00363, Final residual = 0.00032394, No Iterations 4
time step continuity errors : sum local = 8.81033e-08, global = 8.1487e-09, cumulative = 5.12239e-06
GAMG: Solving for p, Initial residual = 0.000549751, Final residual = 9.16181e-07, No Iterations 19
time step continuity errors : sum local = 2.49208e-10, global = -4.85138e-11, cumulative = 5.12234e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00129121, Final residual = 5.33373e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176699, Final residual = 5.78056e-06, No Iterations 4
ExecutionTime = 22.82 s ClockTime = 23 s
Time = 2.2775
Courant Number mean: 0.133297 max: 0.616726
smoothSolver: Solving for Ux, Initial residual = 0.00078615, Final residual = 3.16912e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239443, Final residual = 3.44815e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00362415, Final residual = 0.000322817, No Iterations 4
time step continuity errors : sum local = 8.78502e-08, global = 8.15055e-09, cumulative = 5.13049e-06
GAMG: Solving for p, Initial residual = 0.000547824, Final residual = 9.71946e-07, No Iterations 19
time step continuity errors : sum local = 2.64515e-10, global = -5.26348e-11, cumulative = 5.13044e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00129277, Final residual = 5.34581e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176625, Final residual = 5.7593e-06, No Iterations 4
ExecutionTime = 22.85 s ClockTime = 23 s
Time = 2.28
Courant Number mean: 0.133312 max: 0.616726
smoothSolver: Solving for Ux, Initial residual = 0.000786092, Final residual = 3.1718e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239502, Final residual = 3.44592e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0037931, Final residual = 0.000322761, No Iterations 4
time step continuity errors : sum local = 8.78599e-08, global = 8.13055e-09, cumulative = 5.13857e-06
GAMG: Solving for p, Initial residual = 0.000550034, Final residual = 8.68578e-07, No Iterations 19
time step continuity errors : sum local = 2.36406e-10, global = -4.67188e-11, cumulative = 5.13852e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00129428, Final residual = 5.35628e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176545, Final residual = 5.73732e-06, No Iterations 4
ExecutionTime = 22.88 s ClockTime = 23 s
Time = 2.2825
Courant Number mean: 0.133326 max: 0.616726
smoothSolver: Solving for Ux, Initial residual = 0.000786242, Final residual = 3.17512e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239516, Final residual = 3.44338e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00384105, Final residual = 0.000325164, No Iterations 4
time step continuity errors : sum local = 8.85189e-08, global = 8.18676e-09, cumulative = 5.14671e-06
GAMG: Solving for p, Initial residual = 0.000549575, Final residual = 8.51824e-07, No Iterations 19
time step continuity errors : sum local = 2.31872e-10, global = -4.55879e-11, cumulative = 5.14667e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00129565, Final residual = 5.3747e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176439, Final residual = 5.71614e-06, No Iterations 4
ExecutionTime = 22.9 s ClockTime = 23 s
Time = 2.285
Courant Number mean: 0.133339 max: 0.616726
smoothSolver: Solving for Ux, Initial residual = 0.000786456, Final residual = 3.17852e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239503, Final residual = 3.44154e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00371334, Final residual = 0.000324668, No Iterations 4
time step continuity errors : sum local = 8.83993e-08, global = 8.16209e-09, cumulative = 5.15483e-06
GAMG: Solving for p, Initial residual = 0.000540959, Final residual = 8.93968e-07, No Iterations 19
time step continuity errors : sum local = 2.43388e-10, global = -4.93253e-11, cumulative = 5.15478e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00129715, Final residual = 5.38599e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176344, Final residual = 5.69279e-06, No Iterations 4
ExecutionTime = 22.93 s ClockTime = 23 s
Time = 2.2875
Courant Number mean: 0.133351 max: 0.616725
smoothSolver: Solving for Ux, Initial residual = 0.00078661, Final residual = 3.18143e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239541, Final residual = 3.44037e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00392012, Final residual = 0.000326747, No Iterations 4
time step continuity errors : sum local = 8.89885e-08, global = 8.20847e-09, cumulative = 5.16299e-06
GAMG: Solving for p, Initial residual = 0.000550923, Final residual = 8.7302e-07, No Iterations 19
time step continuity errors : sum local = 2.37736e-10, global = -4.74572e-11, cumulative = 5.16294e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00129862, Final residual = 5.39831e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176238, Final residual = 5.67011e-06, No Iterations 4
ExecutionTime = 22.95 s ClockTime = 23 s
Time = 2.29
Courant Number mean: 0.133363 max: 0.616725
smoothSolver: Solving for Ux, Initial residual = 0.000786727, Final residual = 3.18473e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239587, Final residual = 3.4391e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0039609, Final residual = 0.00033057, No Iterations 4
time step continuity errors : sum local = 9.00574e-08, global = 8.2708e-09, cumulative = 5.17121e-06
GAMG: Solving for p, Initial residual = 0.000554287, Final residual = 9.90891e-07, No Iterations 18
time step continuity errors : sum local = 2.69945e-10, global = 3.20283e-11, cumulative = 5.17124e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013, Final residual = 5.40989e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00176137, Final residual = 5.64768e-06, No Iterations 4
ExecutionTime = 22.99 s ClockTime = 23 s
Time = 2.2925
Courant Number mean: 0.133376 max: 0.616725
smoothSolver: Solving for Ux, Initial residual = 0.000786715, Final residual = 3.1875e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239599, Final residual = 3.43828e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00376672, Final residual = 0.000331351, No Iterations 4
time step continuity errors : sum local = 9.03018e-08, global = 8.31801e-09, cumulative = 5.17956e-06
GAMG: Solving for p, Initial residual = 0.000545968, Final residual = 9.85608e-07, No Iterations 18
time step continuity errors : sum local = 2.68576e-10, global = 3.25149e-11, cumulative = 5.17959e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00130146, Final residual = 5.42247e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017604, Final residual = 5.62825e-06, No Iterations 4
ExecutionTime = 23.01 s ClockTime = 23 s
Time = 2.295
Courant Number mean: 0.1334 max: 0.616725
smoothSolver: Solving for Ux, Initial residual = 0.000786667, Final residual = 3.19056e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239614, Final residual = 3.43839e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00365453, Final residual = 0.000331831, No Iterations 4
time step continuity errors : sum local = 9.04646e-08, global = 8.32971e-09, cumulative = 5.18792e-06
GAMG: Solving for p, Initial residual = 0.000537698, Final residual = 9.73986e-07, No Iterations 18
time step continuity errors : sum local = 2.65535e-10, global = 3.19702e-11, cumulative = 5.18795e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00130297, Final residual = 5.43296e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175941, Final residual = 5.60525e-06, No Iterations 4
ExecutionTime = 23.03 s ClockTime = 23 s
Time = 2.2975
Courant Number mean: 0.133426 max: 0.616725
smoothSolver: Solving for Ux, Initial residual = 0.000786613, Final residual = 3.19371e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239673, Final residual = 3.43907e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00374811, Final residual = 0.000333742, No Iterations 4
time step continuity errors : sum local = 9.10181e-08, global = 8.37776e-09, cumulative = 5.19633e-06
GAMG: Solving for p, Initial residual = 0.00054454, Final residual = 8.75174e-07, No Iterations 19
time step continuity errors : sum local = 2.3866e-10, global = -4.77193e-11, cumulative = 5.19628e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00130433, Final residual = 5.44569e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175828, Final residual = 5.58296e-06, No Iterations 4
ExecutionTime = 23.06 s ClockTime = 23 s
Time = 2.3
Courant Number mean: 0.133451 max: 0.616724
smoothSolver: Solving for Ux, Initial residual = 0.000786519, Final residual = 3.19689e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239754, Final residual = 3.44053e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00388551, Final residual = 0.000335986, No Iterations 4
time step continuity errors : sum local = 9.16585e-08, global = 8.41034e-09, cumulative = 5.20469e-06
GAMG: Solving for p, Initial residual = 0.000554784, Final residual = 9.51729e-07, No Iterations 18
time step continuity errors : sum local = 2.59624e-10, global = 2.93989e-11, cumulative = 5.20472e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00130557, Final residual = 5.4588e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175726, Final residual = 5.55997e-06, No Iterations 4
ExecutionTime = 23.11 s ClockTime = 23 s
Time = 2.3025
Courant Number mean: 0.133476 max: 0.616724
smoothSolver: Solving for Ux, Initial residual = 0.000786399, Final residual = 3.20075e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239853, Final residual = 3.44245e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00381427, Final residual = 0.000338058, No Iterations 4
time step continuity errors : sum local = 9.22666e-08, global = 8.46468e-09, cumulative = 5.21319e-06
GAMG: Solving for p, Initial residual = 0.000552815, Final residual = 9.19109e-07, No Iterations 18
time step continuity errors : sum local = 2.50872e-10, global = 2.71432e-11, cumulative = 5.21322e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00130681, Final residual = 5.47195e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175604, Final residual = 5.53506e-06, No Iterations 4
ExecutionTime = 23.14 s ClockTime = 23 s
Time = 2.305
Courant Number mean: 0.133499 max: 0.616724
smoothSolver: Solving for Ux, Initial residual = 0.000786141, Final residual = 3.20522e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239955, Final residual = 3.44562e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0038757, Final residual = 0.000336245, No Iterations 4
time step continuity errors : sum local = 9.18333e-08, global = 8.46119e-09, cumulative = 5.22168e-06
GAMG: Solving for p, Initial residual = 0.000544149, Final residual = 9.00124e-07, No Iterations 18
time step continuity errors : sum local = 2.45838e-10, global = 2.65507e-11, cumulative = 5.2217e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00130787, Final residual = 5.4836e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175472, Final residual = 5.51339e-06, No Iterations 4
ExecutionTime = 23.16 s ClockTime = 23 s
Time = 2.3075
Courant Number mean: 0.133521 max: 0.616724
smoothSolver: Solving for Ux, Initial residual = 0.000785968, Final residual = 3.21018e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.002401, Final residual = 3.44866e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00375318, Final residual = 0.00033837, No Iterations 4
time step continuity errors : sum local = 9.24593e-08, global = 8.52222e-09, cumulative = 5.23023e-06
GAMG: Solving for p, Initial residual = 0.000554822, Final residual = 8.01695e-07, No Iterations 18
time step continuity errors : sum local = 2.19068e-10, global = 2.06316e-11, cumulative = 5.23025e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00130901, Final residual = 5.49748e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175344, Final residual = 5.49114e-06, No Iterations 4
ExecutionTime = 23.18 s ClockTime = 23 s
Time = 2.31
Courant Number mean: 0.133541 max: 0.616724
smoothSolver: Solving for Ux, Initial residual = 0.00078566, Final residual = 3.21537e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240242, Final residual = 3.45184e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00367817, Final residual = 0.000339426, No Iterations 4
time step continuity errors : sum local = 9.27945e-08, global = 8.57233e-09, cumulative = 5.23882e-06
GAMG: Solving for p, Initial residual = 0.000549906, Final residual = 8.38358e-07, No Iterations 18
time step continuity errors : sum local = 2.2921e-10, global = 2.25968e-11, cumulative = 5.23884e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00131029, Final residual = 5.51229e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175214, Final residual = 5.47062e-06, No Iterations 4
ExecutionTime = 23.21 s ClockTime = 23 s
Time = 2.3125
Courant Number mean: 0.13356 max: 0.616723
smoothSolver: Solving for Ux, Initial residual = 0.00078527, Final residual = 3.2206e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240393, Final residual = 3.4561e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00363304, Final residual = 0.00034085, No Iterations 4
time step continuity errors : sum local = 9.32445e-08, global = 8.60171e-09, cumulative = 5.24744e-06
GAMG: Solving for p, Initial residual = 0.000546439, Final residual = 8.13484e-07, No Iterations 18
time step continuity errors : sum local = 2.22571e-10, global = 2.12178e-11, cumulative = 5.24746e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00131172, Final residual = 5.52666e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00175098, Final residual = 5.45004e-06, No Iterations 4
ExecutionTime = 23.24 s ClockTime = 23 s
Time = 2.315
Courant Number mean: 0.133577 max: 0.616723
smoothSolver: Solving for Ux, Initial residual = 0.000784914, Final residual = 3.22653e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240506, Final residual = 3.46027e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00356479, Final residual = 0.000340851, No Iterations 4
time step continuity errors : sum local = 9.33069e-08, global = 8.61967e-09, cumulative = 5.25608e-06
GAMG: Solving for p, Initial residual = 0.000542826, Final residual = 7.71608e-07, No Iterations 18
time step continuity errors : sum local = 2.1125e-10, global = 1.92935e-11, cumulative = 5.2561e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00131313, Final residual = 5.53984e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00174975, Final residual = 5.42932e-06, No Iterations 4
ExecutionTime = 23.26 s ClockTime = 23 s
Time = 2.3175
Courant Number mean: 0.133594 max: 0.616723
smoothSolver: Solving for Ux, Initial residual = 0.00078473, Final residual = 3.23272e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240591, Final residual = 3.46508e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00378505, Final residual = 0.000342487, No Iterations 4
time step continuity errors : sum local = 9.38095e-08, global = 8.70573e-09, cumulative = 5.26481e-06
GAMG: Solving for p, Initial residual = 0.000561396, Final residual = 7.43588e-07, No Iterations 18
time step continuity errors : sum local = 2.03683e-10, global = 1.82685e-11, cumulative = 5.26483e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00131435, Final residual = 5.55377e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00174855, Final residual = 5.41356e-06, No Iterations 4
ExecutionTime = 23.29 s ClockTime = 23 s
Time = 2.32
Courant Number mean: 0.13361 max: 0.616723
smoothSolver: Solving for Ux, Initial residual = 0.000784585, Final residual = 3.23926e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240628, Final residual = 3.46984e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00375485, Final residual = 0.000342103, No Iterations 4
time step continuity errors : sum local = 9.37551e-08, global = 8.72372e-09, cumulative = 5.27355e-06
GAMG: Solving for p, Initial residual = 0.000560265, Final residual = 7.36603e-07, No Iterations 18
time step continuity errors : sum local = 2.01889e-10, global = 1.80869e-11, cumulative = 5.27357e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00131559, Final residual = 5.58124e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017474, Final residual = 5.3953e-06, No Iterations 4
ExecutionTime = 23.31 s ClockTime = 23 s
Time = 2.3225
Courant Number mean: 0.133624 max: 0.616723
smoothSolver: Solving for Ux, Initial residual = 0.000784443, Final residual = 3.24598e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0024065, Final residual = 3.4748e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00387513, Final residual = 0.000342075, No Iterations 4
time step continuity errors : sum local = 9.38086e-08, global = 8.7638e-09, cumulative = 5.28233e-06
GAMG: Solving for p, Initial residual = 0.000564511, Final residual = 7.20709e-07, No Iterations 18
time step continuity errors : sum local = 1.97664e-10, global = 1.76363e-11, cumulative = 5.28235e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00131691, Final residual = 5.59812e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00174635, Final residual = 5.38154e-06, No Iterations 4
ExecutionTime = 23.33 s ClockTime = 23 s
Time = 2.325
Courant Number mean: 0.133637 max: 0.616722
smoothSolver: Solving for Ux, Initial residual = 0.000784474, Final residual = 3.25309e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240672, Final residual = 3.47995e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00386059, Final residual = 0.000345675, No Iterations 4
time step continuity errors : sum local = 9.48578e-08, global = 8.85374e-09, cumulative = 5.2912e-06
GAMG: Solving for p, Initial residual = 0.000566247, Final residual = 7.11183e-07, No Iterations 18
time step continuity errors : sum local = 1.95185e-10, global = 1.72003e-11, cumulative = 5.29122e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00131839, Final residual = 5.61595e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00174524, Final residual = 5.36449e-06, No Iterations 4
ExecutionTime = 23.36 s ClockTime = 23 s
Time = 2.3275
Courant Number mean: 0.133649 max: 0.616722
smoothSolver: Solving for Ux, Initial residual = 0.000784682, Final residual = 3.26085e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240675, Final residual = 3.48536e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0038812, Final residual = 0.00034877, No Iterations 4
time step continuity errors : sum local = 9.57654e-08, global = 8.93322e-09, cumulative = 5.30015e-06
GAMG: Solving for p, Initial residual = 0.000572933, Final residual = 7.03331e-07, No Iterations 18
time step continuity errors : sum local = 1.93136e-10, global = 1.69105e-11, cumulative = 5.30017e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00132009, Final residual = 5.63245e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00174405, Final residual = 5.34842e-06, No Iterations 4
ExecutionTime = 23.38 s ClockTime = 24 s
Time = 2.33
Courant Number mean: 0.13366 max: 0.616722
smoothSolver: Solving for Ux, Initial residual = 0.000784976, Final residual = 3.26896e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240638, Final residual = 3.49065e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.003926, Final residual = 0.000340208, No Iterations 4
time step continuity errors : sum local = 9.34683e-08, global = 8.80476e-09, cumulative = 5.30898e-06
GAMG: Solving for p, Initial residual = 0.000570254, Final residual = 6.7342e-07, No Iterations 18
time step continuity errors : sum local = 1.85055e-10, global = 1.82162e-11, cumulative = 5.30899e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00132152, Final residual = 5.64865e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00174278, Final residual = 5.33382e-06, No Iterations 4
ExecutionTime = 23.41 s ClockTime = 24 s
Time = 2.3325
Courant Number mean: 0.13367 max: 0.616722
smoothSolver: Solving for Ux, Initial residual = 0.000785205, Final residual = 3.27739e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240649, Final residual = 3.49688e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00390105, Final residual = 0.000342658, No Iterations 4
time step continuity errors : sum local = 9.41982e-08, global = 8.86788e-09, cumulative = 5.31786e-06
GAMG: Solving for p, Initial residual = 0.000566079, Final residual = 6.94631e-07, No Iterations 18
time step continuity errors : sum local = 1.90999e-10, global = 1.92149e-11, cumulative = 5.31788e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00132276, Final residual = 5.66442e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00174142, Final residual = 5.31935e-06, No Iterations 4
ExecutionTime = 23.44 s ClockTime = 24 s
Time = 2.335
Courant Number mean: 0.13368 max: 0.616721
smoothSolver: Solving for Ux, Initial residual = 0.000785434, Final residual = 3.28555e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240668, Final residual = 3.50282e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00389827, Final residual = 0.000340161, No Iterations 4
time step continuity errors : sum local = 9.35658e-08, global = 8.82017e-09, cumulative = 5.3267e-06
GAMG: Solving for p, Initial residual = 0.000563249, Final residual = 6.87397e-07, No Iterations 18
time step continuity errors : sum local = 1.89109e-10, global = 1.8841e-11, cumulative = 5.32672e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00132395, Final residual = 5.68894e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00174012, Final residual = 5.30597e-06, No Iterations 4
ExecutionTime = 23.46 s ClockTime = 24 s
Time = 2.3375
Courant Number mean: 0.133689 max: 0.616721
smoothSolver: Solving for Ux, Initial residual = 0.00078564, Final residual = 3.29389e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240723, Final residual = 3.50981e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00387366, Final residual = 0.000340407, No Iterations 4
time step continuity errors : sum local = 9.36697e-08, global = 8.87025e-09, cumulative = 5.33559e-06
GAMG: Solving for p, Initial residual = 0.00056411, Final residual = 6.78384e-07, No Iterations 18
time step continuity errors : sum local = 1.86713e-10, global = 1.90297e-11, cumulative = 5.33561e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013251, Final residual = 5.70737e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00173885, Final residual = 5.29305e-06, No Iterations 4
ExecutionTime = 23.49 s ClockTime = 24 s
Time = 2.34
Courant Number mean: 0.133699 max: 0.616721
smoothSolver: Solving for Ux, Initial residual = 0.000785895, Final residual = 3.30253e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240745, Final residual = 3.51742e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0038943, Final residual = 0.000338529, No Iterations 4
time step continuity errors : sum local = 9.3204e-08, global = 8.8477e-09, cumulative = 5.34446e-06
GAMG: Solving for p, Initial residual = 0.000567197, Final residual = 7.07034e-07, No Iterations 18
time step continuity errors : sum local = 1.94718e-10, global = 2.01254e-11, cumulative = 5.34448e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00132624, Final residual = 5.72091e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00173757, Final residual = 5.28095e-06, No Iterations 4
ExecutionTime = 23.51 s ClockTime = 24 s
Time = 2.3425
Courant Number mean: 0.133722 max: 0.616721
smoothSolver: Solving for Ux, Initial residual = 0.000786005, Final residual = 3.31122e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240762, Final residual = 3.52422e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00378414, Final residual = 0.000336977, No Iterations 4
time step continuity errors : sum local = 9.28337e-08, global = 8.81621e-09, cumulative = 5.35329e-06
GAMG: Solving for p, Initial residual = 0.000559609, Final residual = 6.73709e-07, No Iterations 18
time step continuity errors : sum local = 1.85647e-10, global = 1.89807e-11, cumulative = 5.35331e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013276, Final residual = 5.73843e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00173623, Final residual = 5.26927e-06, No Iterations 4
ExecutionTime = 23.54 s ClockTime = 24 s
Time = 2.345
Courant Number mean: 0.133747 max: 0.616721
smoothSolver: Solving for Ux, Initial residual = 0.000785981, Final residual = 3.31978e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240822, Final residual = 3.53217e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00368526, Final residual = 0.000336422, No Iterations 4
time step continuity errors : sum local = 9.27489e-08, global = 8.84413e-09, cumulative = 5.36216e-06
GAMG: Solving for p, Initial residual = 0.000551002, Final residual = 6.93708e-07, No Iterations 18
time step continuity errors : sum local = 1.91318e-10, global = 1.97901e-11, cumulative = 5.36218e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00132902, Final residual = 5.75736e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00173499, Final residual = 5.25908e-06, No Iterations 4
ExecutionTime = 23.56 s ClockTime = 24 s
Time = 2.3475
Courant Number mean: 0.133772 max: 0.61672
smoothSolver: Solving for Ux, Initial residual = 0.000785962, Final residual = 3.32953e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240849, Final residual = 3.54e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00389842, Final residual = 0.000336357, No Iterations 4
time step continuity errors : sum local = 9.28101e-08, global = 8.87591e-09, cumulative = 5.37105e-06
GAMG: Solving for p, Initial residual = 0.00055524, Final residual = 6.80132e-07, No Iterations 18
time step continuity errors : sum local = 1.87744e-10, global = 1.94142e-11, cumulative = 5.37107e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00133044, Final residual = 5.77452e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00173373, Final residual = 5.25358e-06, No Iterations 4
ExecutionTime = 23.59 s ClockTime = 24 s
Time = 2.35
Courant Number mean: 0.133796 max: 0.61672
smoothSolver: Solving for Ux, Initial residual = 0.000785949, Final residual = 3.33971e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0024091, Final residual = 3.54884e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00377396, Final residual = 0.000336135, No Iterations 4
time step continuity errors : sum local = 9.28061e-08, global = 8.85252e-09, cumulative = 5.37992e-06
GAMG: Solving for p, Initial residual = 0.000550597, Final residual = 6.61338e-07, No Iterations 18
time step continuity errors : sum local = 1.82612e-10, global = 1.90635e-11, cumulative = 5.37994e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00133191, Final residual = 5.7935e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00173224, Final residual = 5.2448e-06, No Iterations 4
ExecutionTime = 23.62 s ClockTime = 24 s
Time = 2.3525
Courant Number mean: 0.133818 max: 0.61672
smoothSolver: Solving for Ux, Initial residual = 0.000785894, Final residual = 3.35064e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240977, Final residual = 3.55791e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00363, Final residual = 0.000335026, No Iterations 4
time step continuity errors : sum local = 9.25301e-08, global = 8.82915e-09, cumulative = 5.38877e-06
GAMG: Solving for p, Initial residual = 0.000549811, Final residual = 6.38124e-07, No Iterations 18
time step continuity errors : sum local = 1.76269e-10, global = 1.82461e-11, cumulative = 5.38879e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00133346, Final residual = 5.81074e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00173078, Final residual = 5.23559e-06, No Iterations 4
ExecutionTime = 23.64 s ClockTime = 24 s
Time = 2.355
Courant Number mean: 0.133838 max: 0.61672
smoothSolver: Solving for Ux, Initial residual = 0.000785596, Final residual = 3.36088e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0024111, Final residual = 3.56715e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00358105, Final residual = 0.000330886, No Iterations 4
time step continuity errors : sum local = 9.14223e-08, global = 8.74011e-09, cumulative = 5.39753e-06
GAMG: Solving for p, Initial residual = 0.000548754, Final residual = 6.28021e-07, No Iterations 18
time step continuity errors : sum local = 1.73553e-10, global = 1.83741e-11, cumulative = 5.39755e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00133481, Final residual = 5.82863e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00172932, Final residual = 5.22666e-06, No Iterations 4
ExecutionTime = 23.67 s ClockTime = 24 s
Time = 2.3575
Courant Number mean: 0.133857 max: 0.61672
smoothSolver: Solving for Ux, Initial residual = 0.000785274, Final residual = 3.37166e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241179, Final residual = 3.57691e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00358035, Final residual = 0.000329219, No Iterations 4
time step continuity errors : sum local = 9.10152e-08, global = 8.70453e-09, cumulative = 5.40625e-06
GAMG: Solving for p, Initial residual = 0.00054408, Final residual = 6.23458e-07, No Iterations 18
time step continuity errors : sum local = 1.72394e-10, global = 1.81361e-11, cumulative = 5.40627e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00133626, Final residual = 5.84771e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00172795, Final residual = 5.22049e-06, No Iterations 4
ExecutionTime = 23.69 s ClockTime = 24 s
Time = 2.36
Courant Number mean: 0.133875 max: 0.616719
smoothSolver: Solving for Ux, Initial residual = 0.000784988, Final residual = 3.38218e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241227, Final residual = 3.58576e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00352889, Final residual = 0.000326283, No Iterations 4
time step continuity errors : sum local = 9.02488e-08, global = 8.63506e-09, cumulative = 5.41491e-06
GAMG: Solving for p, Initial residual = 0.00054692, Final residual = 9.87913e-07, No Iterations 17
time step continuity errors : sum local = 2.7332e-10, global = -5.98205e-11, cumulative = 5.41485e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00133795, Final residual = 5.86788e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00172672, Final residual = 5.21462e-06, No Iterations 4
ExecutionTime = 23.72 s ClockTime = 24 s
Time = 2.3625
Courant Number mean: 0.13389 max: 0.616719
smoothSolver: Solving for Ux, Initial residual = 0.000784794, Final residual = 3.39244e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241321, Final residual = 3.59538e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00354156, Final residual = 0.000324595, No Iterations 4
time step continuity errors : sum local = 8.98215e-08, global = 8.59785e-09, cumulative = 5.42345e-06
GAMG: Solving for p, Initial residual = 0.000551458, Final residual = 6.24017e-07, No Iterations 18
time step continuity errors : sum local = 1.72706e-10, global = 1.81428e-11, cumulative = 5.42346e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013397, Final residual = 5.88687e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00172555, Final residual = 5.21012e-06, No Iterations 4
ExecutionTime = 23.74 s ClockTime = 24 s
Time = 2.365
Courant Number mean: 0.133904 max: 0.616719
smoothSolver: Solving for Ux, Initial residual = 0.000784733, Final residual = 3.403e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241366, Final residual = 3.60434e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00362373, Final residual = 0.000323661, No Iterations 4
time step continuity errors : sum local = 8.96048e-08, global = 8.57495e-09, cumulative = 5.43204e-06
GAMG: Solving for p, Initial residual = 0.000558587, Final residual = 6.21268e-07, No Iterations 18
time step continuity errors : sum local = 1.72047e-10, global = 1.80304e-11, cumulative = 5.43206e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00134119, Final residual = 5.90616e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00172416, Final residual = 5.20542e-06, No Iterations 4
ExecutionTime = 23.76 s ClockTime = 24 s
Time = 2.3675
Courant Number mean: 0.133917 max: 0.616719
smoothSolver: Solving for Ux, Initial residual = 0.00078475, Final residual = 3.41353e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241387, Final residual = 3.61334e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00352601, Final residual = 0.00032167, No Iterations 4
time step continuity errors : sum local = 8.91044e-08, global = 8.48408e-09, cumulative = 5.44054e-06
GAMG: Solving for p, Initial residual = 0.000551421, Final residual = 6.16876e-07, No Iterations 18
time step continuity errors : sum local = 1.70919e-10, global = 1.7765e-11, cumulative = 5.44056e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013425, Final residual = 5.93336e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00172292, Final residual = 5.20128e-06, No Iterations 4
ExecutionTime = 23.79 s ClockTime = 24 s
Time = 2.37
Courant Number mean: 0.133928 max: 0.616719
smoothSolver: Solving for Ux, Initial residual = 0.000784787, Final residual = 3.4247e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241405, Final residual = 3.62213e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00337883, Final residual = 0.000320757, No Iterations 4
time step continuity errors : sum local = 8.88956e-08, global = 8.45176e-09, cumulative = 5.44901e-06
GAMG: Solving for p, Initial residual = 0.00054182, Final residual = 9.71168e-07, No Iterations 17
time step continuity errors : sum local = 2.6922e-10, global = -5.95235e-11, cumulative = 5.44895e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00134379, Final residual = 5.95288e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017218, Final residual = 5.19824e-06, No Iterations 4
ExecutionTime = 23.82 s ClockTime = 24 s
Time = 2.3725
Courant Number mean: 0.133937 max: 0.616719
smoothSolver: Solving for Ux, Initial residual = 0.000784935, Final residual = 3.43596e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241408, Final residual = 3.6312e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00380093, Final residual = 0.000318108, No Iterations 4
time step continuity errors : sum local = 8.82044e-08, global = 8.32544e-09, cumulative = 5.45728e-06
GAMG: Solving for p, Initial residual = 0.000572092, Final residual = 9.29761e-07, No Iterations 16
time step continuity errors : sum local = 2.57865e-10, global = 2.26793e-11, cumulative = 5.4573e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00134514, Final residual = 5.9739e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00172064, Final residual = 5.20128e-06, No Iterations 4
ExecutionTime = 23.84 s ClockTime = 24 s
Time = 2.375
Courant Number mean: 0.133945 max: 0.616718
smoothSolver: Solving for Ux, Initial residual = 0.00078515, Final residual = 3.44742e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241399, Final residual = 3.63974e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00387838, Final residual = 0.000312728, No Iterations 4
time step continuity errors : sum local = 8.67477e-08, global = 8.24223e-09, cumulative = 5.46554e-06
GAMG: Solving for p, Initial residual = 0.000575892, Final residual = 8.84733e-07, No Iterations 16
time step continuity errors : sum local = 2.45451e-10, global = 2.11772e-11, cumulative = 5.46556e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00134647, Final residual = 5.99388e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00171944, Final residual = 5.19993e-06, No Iterations 4
ExecutionTime = 23.87 s ClockTime = 24 s
Time = 2.3775
Courant Number mean: 0.133952 max: 0.616718
smoothSolver: Solving for Ux, Initial residual = 0.000785427, Final residual = 3.45896e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241407, Final residual = 3.6481e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00392007, Final residual = 0.000311436, No Iterations 4
time step continuity errors : sum local = 8.64267e-08, global = 8.22627e-09, cumulative = 5.47379e-06
GAMG: Solving for p, Initial residual = 0.000572496, Final residual = 8.36521e-07, No Iterations 16
time step continuity errors : sum local = 2.3219e-10, global = 1.99999e-11, cumulative = 5.47381e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00134794, Final residual = 6.01496e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00171826, Final residual = 5.19802e-06, No Iterations 4
ExecutionTime = 23.9 s ClockTime = 24 s
Time = 2.38
Courant Number mean: 0.133958 max: 0.616718
smoothSolver: Solving for Ux, Initial residual = 0.00078585, Final residual = 3.47056e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241448, Final residual = 3.65693e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00390488, Final residual = 0.00031161, No Iterations 4
time step continuity errors : sum local = 8.65019e-08, global = 8.15305e-09, cumulative = 5.48196e-06
GAMG: Solving for p, Initial residual = 0.000568, Final residual = 8.74344e-07, No Iterations 16
time step continuity errors : sum local = 2.4276e-10, global = 2.08297e-11, cumulative = 5.48198e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00134917, Final residual = 6.03316e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00171715, Final residual = 5.19788e-06, No Iterations 4
ExecutionTime = 23.93 s ClockTime = 24 s
Time = 2.3825
Courant Number mean: 0.133963 max: 0.616718
smoothSolver: Solving for Ux, Initial residual = 0.000786206, Final residual = 3.48159e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241454, Final residual = 3.66537e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00390629, Final residual = 0.000311117, No Iterations 4
time step continuity errors : sum local = 8.63879e-08, global = 8.13366e-09, cumulative = 5.49012e-06
GAMG: Solving for p, Initial residual = 0.000566706, Final residual = 8.06281e-07, No Iterations 16
time step continuity errors : sum local = 2.23906e-10, global = 1.89356e-11, cumulative = 5.49013e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00135049, Final residual = 6.05145e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00171614, Final residual = 5.19664e-06, No Iterations 4
ExecutionTime = 23.95 s ClockTime = 24 s
Time = 2.385
Courant Number mean: 0.133968 max: 0.616718
smoothSolver: Solving for Ux, Initial residual = 0.000786487, Final residual = 3.49244e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241454, Final residual = 3.67414e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00382612, Final residual = 0.000313267, No Iterations 4
time step continuity errors : sum local = 8.70047e-08, global = 8.1432e-09, cumulative = 5.49828e-06
GAMG: Solving for p, Initial residual = 0.000565936, Final residual = 8.55538e-07, No Iterations 16
time step continuity errors : sum local = 2.37648e-10, global = 2.06911e-11, cumulative = 5.4983e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013518, Final residual = 6.07272e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00171527, Final residual = 5.19707e-06, No Iterations 4
ExecutionTime = 23.98 s ClockTime = 24 s
Time = 2.3875
Courant Number mean: 0.133973 max: 0.616718
smoothSolver: Solving for Ux, Initial residual = 0.000786666, Final residual = 3.50301e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241464, Final residual = 3.68327e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00380667, Final residual = 0.00031358, No Iterations 4
time step continuity errors : sum local = 8.71175e-08, global = 8.19775e-09, cumulative = 5.5065e-06
GAMG: Solving for p, Initial residual = 0.000570296, Final residual = 8.5166e-07, No Iterations 16
time step continuity errors : sum local = 2.36651e-10, global = 2.05085e-11, cumulative = 5.50652e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00135313, Final residual = 6.10054e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00171424, Final residual = 5.19802e-06, No Iterations 4
ExecutionTime = 24 s ClockTime = 24 s
Time = 2.39
Courant Number mean: 0.133992 max: 0.616717
smoothSolver: Solving for Ux, Initial residual = 0.000786735, Final residual = 3.51456e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241445, Final residual = 3.69143e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00371961, Final residual = 0.000308256, No Iterations 4
time step continuity errors : sum local = 8.56687e-08, global = 7.97575e-09, cumulative = 5.51449e-06
GAMG: Solving for p, Initial residual = 0.000558437, Final residual = 8.37072e-07, No Iterations 16
time step continuity errors : sum local = 2.32693e-10, global = 1.93579e-11, cumulative = 5.51451e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00135455, Final residual = 6.12071e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00171327, Final residual = 5.19903e-06, No Iterations 4
ExecutionTime = 24.03 s ClockTime = 24 s
Time = 2.3925
Courant Number mean: 0.134014 max: 0.616717
smoothSolver: Solving for Ux, Initial residual = 0.000786801, Final residual = 3.52576e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241512, Final residual = 3.70221e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00368774, Final residual = 0.000312884, No Iterations 4
time step continuity errors : sum local = 8.69884e-08, global = 8.07563e-09, cumulative = 5.52259e-06
GAMG: Solving for p, Initial residual = 0.000561938, Final residual = 8.21072e-07, No Iterations 16
time step continuity errors : sum local = 2.28319e-10, global = 1.94354e-11, cumulative = 5.52261e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00135594, Final residual = 6.14317e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00171225, Final residual = 5.20086e-06, No Iterations 4
ExecutionTime = 24.05 s ClockTime = 24 s
Time = 2.395
Courant Number mean: 0.134035 max: 0.616717
smoothSolver: Solving for Ux, Initial residual = 0.000786825, Final residual = 3.53826e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241503, Final residual = 3.71139e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00368063, Final residual = 0.000312422, No Iterations 4
time step continuity errors : sum local = 8.68951e-08, global = 8.02759e-09, cumulative = 5.53063e-06
GAMG: Solving for p, Initial residual = 0.000555466, Final residual = 8.16216e-07, No Iterations 16
time step continuity errors : sum local = 2.27085e-10, global = 1.91124e-11, cumulative = 5.53065e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00135744, Final residual = 6.16445e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00171124, Final residual = 5.20277e-06, No Iterations 4
ExecutionTime = 24.08 s ClockTime = 24 s
Time = 2.3975
Courant Number mean: 0.134055 max: 0.616717
smoothSolver: Solving for Ux, Initial residual = 0.000786622, Final residual = 3.55032e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241497, Final residual = 3.72145e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00392917, Final residual = 0.000312326, No Iterations 4
time step continuity errors : sum local = 8.69303e-08, global = 8.01725e-09, cumulative = 5.53867e-06
GAMG: Solving for p, Initial residual = 0.000557916, Final residual = 8.05049e-07, No Iterations 16
time step continuity errors : sum local = 2.24158e-10, global = 1.89163e-11, cumulative = 5.53869e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00135893, Final residual = 6.18139e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00171016, Final residual = 5.21019e-06, No Iterations 4
ExecutionTime = 24.1 s ClockTime = 24 s
Time = 2.4
Courant Number mean: 0.134074 max: 0.616717
smoothSolver: Solving for Ux, Initial residual = 0.000786329, Final residual = 3.56303e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241524, Final residual = 3.73136e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00385132, Final residual = 0.000307593, No Iterations 4
time step continuity errors : sum local = 8.56417e-08, global = 7.88114e-09, cumulative = 5.54657e-06
GAMG: Solving for p, Initial residual = 0.000551174, Final residual = 7.51918e-07, No Iterations 16
time step continuity errors : sum local = 2.09382e-10, global = 1.68892e-11, cumulative = 5.54659e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136027, Final residual = 6.20842e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00170901, Final residual = 5.21331e-06, No Iterations 4
ExecutionTime = 24.16 s ClockTime = 24 s
Time = 2.4025
Courant Number mean: 0.134091 max: 0.616717
smoothSolver: Solving for Ux, Initial residual = 0.000785952, Final residual = 3.57432e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0024162, Final residual = 3.74198e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00373022, Final residual = 0.000307429, No Iterations 4
time step continuity errors : sum local = 8.56075e-08, global = 7.91697e-09, cumulative = 5.5545e-06
GAMG: Solving for p, Initial residual = 0.000548516, Final residual = 7.48828e-07, No Iterations 16
time step continuity errors : sum local = 2.08542e-10, global = 1.73974e-11, cumulative = 5.55452e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136145, Final residual = 6.22815e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00170805, Final residual = 5.21691e-06, No Iterations 4
ExecutionTime = 24.18 s ClockTime = 24 s
Time = 2.405
Courant Number mean: 0.134106 max: 0.616717
smoothSolver: Solving for Ux, Initial residual = 0.0007858, Final residual = 3.58641e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241692, Final residual = 3.75194e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00358532, Final residual = 0.000309341, No Iterations 4
time step continuity errors : sum local = 8.61464e-08, global = 7.8805e-09, cumulative = 5.5624e-06
GAMG: Solving for p, Initial residual = 0.000546218, Final residual = 7.52075e-07, No Iterations 16
time step continuity errors : sum local = 2.0947e-10, global = 1.73967e-11, cumulative = 5.56242e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136253, Final residual = 6.24812e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017073, Final residual = 5.22137e-06, No Iterations 4
ExecutionTime = 24.2 s ClockTime = 24 s
Time = 2.4075
Courant Number mean: 0.134119 max: 0.616717
smoothSolver: Solving for Ux, Initial residual = 0.000785657, Final residual = 3.59798e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241724, Final residual = 3.76261e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00368891, Final residual = 0.000308211, No Iterations 4
time step continuity errors : sum local = 8.58536e-08, global = 7.80463e-09, cumulative = 5.57022e-06
GAMG: Solving for p, Initial residual = 0.000558756, Final residual = 7.45674e-07, No Iterations 16
time step continuity errors : sum local = 2.07741e-10, global = 1.71394e-11, cumulative = 5.57024e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136377, Final residual = 6.26815e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00170658, Final residual = 5.22641e-06, No Iterations 4
ExecutionTime = 24.23 s ClockTime = 24 s
Time = 2.41
Courant Number mean: 0.134131 max: 0.616716
smoothSolver: Solving for Ux, Initial residual = 0.000785551, Final residual = 3.60987e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241729, Final residual = 3.77315e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00358556, Final residual = 0.000310231, No Iterations 4
time step continuity errors : sum local = 8.64356e-08, global = 7.85822e-09, cumulative = 5.5781e-06
GAMG: Solving for p, Initial residual = 0.000555556, Final residual = 7.52911e-07, No Iterations 16
time step continuity errors : sum local = 2.0982e-10, global = 1.72768e-11, cumulative = 5.57812e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136517, Final residual = 6.28902e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00170587, Final residual = 5.2309e-06, No Iterations 4
ExecutionTime = 24.25 s ClockTime = 24 s
Time = 2.4125
Courant Number mean: 0.134141 max: 0.616716
smoothSolver: Solving for Ux, Initial residual = 0.000785524, Final residual = 3.62202e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241724, Final residual = 3.78399e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00375995, Final residual = 0.000309161, No Iterations 4
time step continuity errors : sum local = 8.61627e-08, global = 7.78892e-09, cumulative = 5.58591e-06
GAMG: Solving for p, Initial residual = 0.000562549, Final residual = 7.38441e-07, No Iterations 16
time step continuity errors : sum local = 2.0586e-10, global = 1.68458e-11, cumulative = 5.58592e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136657, Final residual = 6.31103e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.001705, Final residual = 5.23637e-06, No Iterations 4
ExecutionTime = 24.28 s ClockTime = 24 s
Time = 2.415
Courant Number mean: 0.134149 max: 0.616716
smoothSolver: Solving for Ux, Initial residual = 0.000785623, Final residual = 3.6344e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241701, Final residual = 3.79465e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00369065, Final residual = 0.000307591, No Iterations 4
time step continuity errors : sum local = 8.57617e-08, global = 7.69283e-09, cumulative = 5.59362e-06
GAMG: Solving for p, Initial residual = 0.000563855, Final residual = 7.38231e-07, No Iterations 16
time step continuity errors : sum local = 2.05888e-10, global = 1.67858e-11, cumulative = 5.59363e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136794, Final residual = 6.33234e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0017044, Final residual = 5.24232e-06, No Iterations 4
ExecutionTime = 24.3 s ClockTime = 25 s
Time = 2.4175
Courant Number mean: 0.134156 max: 0.616716
smoothSolver: Solving for Ux, Initial residual = 0.000785849, Final residual = 3.64719e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241664, Final residual = 3.80505e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00357908, Final residual = 0.000305774, No Iterations 4
time step continuity errors : sum local = 8.52816e-08, global = 7.60788e-09, cumulative = 5.60124e-06
GAMG: Solving for p, Initial residual = 0.000563067, Final residual = 7.42191e-07, No Iterations 16
time step continuity errors : sum local = 2.07041e-10, global = 1.66939e-11, cumulative = 5.60126e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136947, Final residual = 6.35318e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00170374, Final residual = 5.24784e-06, No Iterations 4
ExecutionTime = 24.33 s ClockTime = 25 s
Time = 2.42
Courant Number mean: 0.134162 max: 0.616716
smoothSolver: Solving for Ux, Initial residual = 0.000786126, Final residual = 3.65971e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241671, Final residual = 3.81632e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00360816, Final residual = 0.000305217, No Iterations 4
time step continuity errors : sum local = 8.51443e-08, global = 7.1514e-09, cumulative = 5.60841e-06
GAMG: Solving for p, Initial residual = 0.000564638, Final residual = 7.21506e-07, No Iterations 16
time step continuity errors : sum local = 2.01293e-10, global = 1.63488e-11, cumulative = 5.60843e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00137091, Final residual = 6.37519e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00170311, Final residual = 5.25429e-06, No Iterations 4
ExecutionTime = 24.35 s ClockTime = 25 s
Time = 2.4225
Courant Number mean: 0.134167 max: 0.616716
smoothSolver: Solving for Ux, Initial residual = 0.000786427, Final residual = 3.67267e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241666, Final residual = 3.82783e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00359573, Final residual = 0.000303395, No Iterations 4
time step continuity errors : sum local = 8.46398e-08, global = 6.93339e-09, cumulative = 5.61536e-06
GAMG: Solving for p, Initial residual = 0.000571898, Final residual = 8.11501e-07, No Iterations 16
time step continuity errors : sum local = 2.26412e-10, global = 1.87931e-11, cumulative = 5.61538e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00137242, Final residual = 6.3969e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00170253, Final residual = 5.26069e-06, No Iterations 4
ExecutionTime = 24.38 s ClockTime = 25 s
Time = 2.425
Courant Number mean: 0.13417 max: 0.616716
smoothSolver: Solving for Ux, Initial residual = 0.000786793, Final residual = 3.68502e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241662, Final residual = 3.84001e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00374739, Final residual = 0.000304758, No Iterations 4
time step continuity errors : sum local = 8.50299e-08, global = 6.92317e-09, cumulative = 5.6223e-06
GAMG: Solving for p, Initial residual = 0.000592808, Final residual = 8.49116e-07, No Iterations 16
time step continuity errors : sum local = 2.3694e-10, global = 1.97818e-11, cumulative = 5.62232e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00137394, Final residual = 6.41644e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00170191, Final residual = 5.26621e-06, No Iterations 4
ExecutionTime = 24.4 s ClockTime = 25 s
Time = 2.4275
Courant Number mean: 0.134172 max: 0.616716
smoothSolver: Solving for Ux, Initial residual = 0.000787219, Final residual = 3.69713e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241623, Final residual = 3.85213e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00373772, Final residual = 0.000304223, No Iterations 4
time step continuity errors : sum local = 8.48874e-08, global = 6.88785e-09, cumulative = 5.62921e-06
GAMG: Solving for p, Initial residual = 0.000592608, Final residual = 8.28972e-07, No Iterations 16
time step continuity errors : sum local = 2.3133e-10, global = 1.91732e-11, cumulative = 5.62923e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00137544, Final residual = 6.43813e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00170134, Final residual = 5.27317e-06, No Iterations 4
ExecutionTime = 24.43 s ClockTime = 25 s
Time = 2.43
Courant Number mean: 0.134174 max: 0.616715
smoothSolver: Solving for Ux, Initial residual = 0.000787503, Final residual = 3.70875e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241639, Final residual = 3.86461e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0037796, Final residual = 0.000299592, No Iterations 4
time step continuity errors : sum local = 8.35972e-08, global = 6.84623e-09, cumulative = 5.63607e-06
GAMG: Solving for p, Initial residual = 0.000599542, Final residual = 7.82611e-07, No Iterations 16
time step continuity errors : sum local = 2.18398e-10, global = 1.78733e-11, cumulative = 5.63609e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00137697, Final residual = 6.4618e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00170088, Final residual = 5.28632e-06, No Iterations 4
ExecutionTime = 24.46 s ClockTime = 25 s
Time = 2.4325
Courant Number mean: 0.134176 max: 0.616715
smoothSolver: Solving for Ux, Initial residual = 0.000787682, Final residual = 3.72063e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241642, Final residual = 3.87727e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00389092, Final residual = 0.000295615, No Iterations 4
time step continuity errors : sum local = 8.24971e-08, global = 6.81752e-09, cumulative = 5.64291e-06
GAMG: Solving for p, Initial residual = 0.000597832, Final residual = 7.42605e-07, No Iterations 16
time step continuity errors : sum local = 2.07275e-10, global = 1.67602e-11, cumulative = 5.64293e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00137838, Final residual = 6.48381e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00170023, Final residual = 5.29363e-06, No Iterations 4
ExecutionTime = 24.49 s ClockTime = 25 s
Time = 2.435
Courant Number mean: 0.134182 max: 0.616715
smoothSolver: Solving for Ux, Initial residual = 0.00078776, Final residual = 3.7332e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241646, Final residual = 3.89041e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00377758, Final residual = 0.000297912, No Iterations 4
time step continuity errors : sum local = 8.31594e-08, global = 6.83381e-09, cumulative = 5.64976e-06
GAMG: Solving for p, Initial residual = 0.000590103, Final residual = 7.9971e-07, No Iterations 16
time step continuity errors : sum local = 2.23286e-10, global = 1.83409e-11, cumulative = 5.64978e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00137961, Final residual = 6.50616e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169952, Final residual = 5.30221e-06, No Iterations 4
ExecutionTime = 24.52 s ClockTime = 25 s
Time = 2.4375
Courant Number mean: 0.1342 max: 0.616715
smoothSolver: Solving for Ux, Initial residual = 0.000787768, Final residual = 3.74634e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241656, Final residual = 3.9036e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00359313, Final residual = 0.00029458, No Iterations 4
time step continuity errors : sum local = 8.22552e-08, global = 6.84973e-09, cumulative = 5.65663e-06
GAMG: Solving for p, Initial residual = 0.000578518, Final residual = 7.4292e-07, No Iterations 16
time step continuity errors : sum local = 2.07497e-10, global = 1.6776e-11, cumulative = 5.65664e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00138093, Final residual = 6.52745e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169886, Final residual = 5.30961e-06, No Iterations 4
ExecutionTime = 24.54 s ClockTime = 25 s
Time = 2.44
Courant Number mean: 0.13422 max: 0.616715
smoothSolver: Solving for Ux, Initial residual = 0.00078774, Final residual = 3.75959e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241651, Final residual = 3.91757e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00357279, Final residual = 0.000291663, No Iterations 4
time step continuity errors : sum local = 8.14635e-08, global = 6.81524e-09, cumulative = 5.66346e-06
GAMG: Solving for p, Initial residual = 0.00057763, Final residual = 6.97144e-07, No Iterations 16
time step continuity errors : sum local = 1.94763e-10, global = 1.55219e-11, cumulative = 5.66348e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00138206, Final residual = 6.54967e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169818, Final residual = 5.31841e-06, No Iterations 4
ExecutionTime = 24.57 s ClockTime = 25 s
Time = 2.4425
Courant Number mean: 0.13424 max: 0.616715
smoothSolver: Solving for Ux, Initial residual = 0.000787604, Final residual = 3.77357e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241657, Final residual = 3.93195e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00365389, Final residual = 0.000289127, No Iterations 4
time step continuity errors : sum local = 8.07973e-08, global = 6.7913e-09, cumulative = 5.67027e-06
GAMG: Solving for p, Initial residual = 0.000569961, Final residual = 7.33297e-07, No Iterations 16
time step continuity errors : sum local = 2.0501e-10, global = 1.65343e-11, cumulative = 5.67028e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00138343, Final residual = 6.57318e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169749, Final residual = 5.32725e-06, No Iterations 4
ExecutionTime = 24.59 s ClockTime = 25 s
Time = 2.445
Courant Number mean: 0.134258 max: 0.616715
smoothSolver: Solving for Ux, Initial residual = 0.000787308, Final residual = 3.78761e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241678, Final residual = 3.94633e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00350613, Final residual = 0.000291817, No Iterations 4
time step continuity errors : sum local = 8.15779e-08, global = 6.87306e-09, cumulative = 5.67716e-06
GAMG: Solving for p, Initial residual = 0.00056241, Final residual = 9.2212e-07, No Iterations 16
time step continuity errors : sum local = 2.57793e-10, global = 2.33486e-11, cumulative = 5.67718e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013848, Final residual = 6.59608e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169657, Final residual = 5.33687e-06, No Iterations 4
ExecutionTime = 24.61 s ClockTime = 25 s
Time = 2.4475
Courant Number mean: 0.134275 max: 0.616715
smoothSolver: Solving for Ux, Initial residual = 0.000787038, Final residual = 3.80189e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0024167, Final residual = 3.96044e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00356858, Final residual = 0.000293489, No Iterations 4
time step continuity errors : sum local = 8.20356e-08, global = 6.91936e-09, cumulative = 5.6841e-06
GAMG: Solving for p, Initial residual = 0.000570484, Final residual = 9.10711e-07, No Iterations 16
time step continuity errors : sum local = 2.54555e-10, global = 2.25724e-11, cumulative = 5.68412e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00138593, Final residual = 6.61923e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0016959, Final residual = 5.34601e-06, No Iterations 4
ExecutionTime = 24.64 s ClockTime = 25 s
Time = 2.45
Courant Number mean: 0.134289 max: 0.616715
smoothSolver: Solving for Ux, Initial residual = 0.000786995, Final residual = 3.81614e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241675, Final residual = 3.97455e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00346045, Final residual = 0.000290966, No Iterations 4
time step continuity errors : sum local = 8.13181e-08, global = 6.85238e-09, cumulative = 5.69097e-06
GAMG: Solving for p, Initial residual = 0.000567802, Final residual = 9.35709e-07, No Iterations 16
time step continuity errors : sum local = 2.61521e-10, global = 2.35627e-11, cumulative = 5.691e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00138696, Final residual = 6.64082e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169534, Final residual = 5.35615e-06, No Iterations 4
ExecutionTime = 24.66 s ClockTime = 25 s
Time = 2.4525
Courant Number mean: 0.134301 max: 0.616714
smoothSolver: Solving for Ux, Initial residual = 0.000787135, Final residual = 3.83054e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241672, Final residual = 3.98865e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00356049, Final residual = 0.000292775, No Iterations 4
time step continuity errors : sum local = 8.18269e-08, global = 6.91231e-09, cumulative = 5.69791e-06
GAMG: Solving for p, Initial residual = 0.000573857, Final residual = 8.02067e-07, No Iterations 16
time step continuity errors : sum local = 2.24171e-10, global = 1.86976e-11, cumulative = 5.69793e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00138832, Final residual = 6.66389e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169488, Final residual = 5.36923e-06, No Iterations 4
ExecutionTime = 24.69 s ClockTime = 25 s
Time = 2.455
Courant Number mean: 0.134312 max: 0.616714
smoothSolver: Solving for Ux, Initial residual = 0.000787201, Final residual = 3.845e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241667, Final residual = 4.00248e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00349964, Final residual = 0.000291751, No Iterations 4
time step continuity errors : sum local = 8.15374e-08, global = 6.92825e-09, cumulative = 5.70486e-06
GAMG: Solving for p, Initial residual = 0.00057163, Final residual = 7.91456e-07, No Iterations 16
time step continuity errors : sum local = 2.21208e-10, global = 1.82831e-11, cumulative = 5.70487e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00138968, Final residual = 6.67793e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169438, Final residual = 5.3792e-06, No Iterations 4
ExecutionTime = 24.71 s ClockTime = 25 s
Time = 2.4575
Courant Number mean: 0.134321 max: 0.616714
smoothSolver: Solving for Ux, Initial residual = 0.000787336, Final residual = 3.85998e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241665, Final residual = 4.01622e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00341927, Final residual = 0.000292361, No Iterations 4
time step continuity errors : sum local = 8.16968e-08, global = 6.81239e-09, cumulative = 5.71169e-06
GAMG: Solving for p, Initial residual = 0.00056324, Final residual = 8.20234e-07, No Iterations 16
time step continuity errors : sum local = 2.29202e-10, global = 1.94227e-11, cumulative = 5.71171e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139119, Final residual = 6.70039e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169385, Final residual = 5.39017e-06, No Iterations 4
ExecutionTime = 24.74 s ClockTime = 25 s
Time = 2.46
Courant Number mean: 0.134328 max: 0.616714
smoothSolver: Solving for Ux, Initial residual = 0.000787538, Final residual = 3.87473e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0024165, Final residual = 4.03235e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00344646, Final residual = 0.000293093, No Iterations 4
time step continuity errors : sum local = 8.1897e-08, global = 6.73306e-09, cumulative = 5.71844e-06
GAMG: Solving for p, Initial residual = 0.000568602, Final residual = 8.52103e-07, No Iterations 16
time step continuity errors : sum local = 2.38094e-10, global = 2.07187e-11, cumulative = 5.71846e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013924, Final residual = 6.72324e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169322, Final residual = 5.40077e-06, No Iterations 4
ExecutionTime = 24.76 s ClockTime = 25 s
Time = 2.4625
Courant Number mean: 0.134333 max: 0.616714
smoothSolver: Solving for Ux, Initial residual = 0.000787731, Final residual = 3.89005e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241615, Final residual = 4.04661e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00345491, Final residual = 0.000293679, No Iterations 4
time step continuity errors : sum local = 8.20478e-08, global = 6.83784e-09, cumulative = 5.7253e-06
GAMG: Solving for p, Initial residual = 0.000578461, Final residual = 7.7709e-07, No Iterations 16
time step continuity errors : sum local = 2.1711e-10, global = 1.77639e-11, cumulative = 5.72532e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139347, Final residual = 6.74845e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169272, Final residual = 5.41222e-06, No Iterations 4
ExecutionTime = 24.78 s ClockTime = 25 s
Time = 2.465
Courant Number mean: 0.134337 max: 0.616714
smoothSolver: Solving for Ux, Initial residual = 0.000787863, Final residual = 3.90575e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241575, Final residual = 4.06117e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00351309, Final residual = 0.000295023, No Iterations 4
time step continuity errors : sum local = 8.24279e-08, global = 6.84039e-09, cumulative = 5.73216e-06
GAMG: Solving for p, Initial residual = 0.000585209, Final residual = 7.53474e-07, No Iterations 16
time step continuity errors : sum local = 2.1053e-10, global = 1.69825e-11, cumulative = 5.73217e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139481, Final residual = 6.77263e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169223, Final residual = 5.42828e-06, No Iterations 4
ExecutionTime = 24.81 s ClockTime = 25 s
Time = 2.4675
Courant Number mean: 0.134339 max: 0.616714
smoothSolver: Solving for Ux, Initial residual = 0.000787983, Final residual = 3.92185e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241522, Final residual = 4.07626e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00370575, Final residual = 0.000295812, No Iterations 4
time step continuity errors : sum local = 8.263e-08, global = 6.81571e-09, cumulative = 5.73899e-06
GAMG: Solving for p, Initial residual = 0.000593543, Final residual = 8.74579e-07, No Iterations 16
time step continuity errors : sum local = 2.44275e-10, global = 2.15403e-11, cumulative = 5.73901e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139599, Final residual = 6.79684e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169174, Final residual = 5.44115e-06, No Iterations 4
ExecutionTime = 24.83 s ClockTime = 25 s
Time = 2.47
Courant Number mean: 0.13434 max: 0.616714
smoothSolver: Solving for Ux, Initial residual = 0.000788112, Final residual = 3.93713e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241517, Final residual = 4.09389e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0036451, Final residual = 0.000299574, No Iterations 4
time step continuity errors : sum local = 8.36604e-08, global = 6.74532e-09, cumulative = 5.74576e-06
GAMG: Solving for p, Initial residual = 0.000589894, Final residual = 7.77224e-07, No Iterations 16
time step continuity errors : sum local = 2.17051e-10, global = 1.78949e-11, cumulative = 5.74577e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139695, Final residual = 6.81947e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169128, Final residual = 5.45359e-06, No Iterations 4
ExecutionTime = 24.85 s ClockTime = 25 s
Time = 2.4725
Courant Number mean: 0.134339 max: 0.616713
smoothSolver: Solving for Ux, Initial residual = 0.000788403, Final residual = 3.9527e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241515, Final residual = 4.11081e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00386352, Final residual = 0.000302782, No Iterations 4
time step continuity errors : sum local = 8.45158e-08, global = 6.62763e-09, cumulative = 5.7524e-06
GAMG: Solving for p, Initial residual = 0.000606479, Final residual = 7.89646e-07, No Iterations 16
time step continuity errors : sum local = 2.20347e-10, global = 1.82823e-11, cumulative = 5.75242e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139784, Final residual = 6.84264e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169082, Final residual = 5.47215e-06, No Iterations 4
ExecutionTime = 24.87 s ClockTime = 25 s
Time = 2.475
Courant Number mean: 0.134337 max: 0.616713
smoothSolver: Solving for Ux, Initial residual = 0.000788646, Final residual = 3.96843e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241513, Final residual = 4.12837e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00378486, Final residual = 0.000305597, No Iterations 4
time step continuity errors : sum local = 8.52459e-08, global = 6.52369e-09, cumulative = 5.75894e-06
GAMG: Solving for p, Initial residual = 0.000607206, Final residual = 7.50235e-07, No Iterations 16
time step continuity errors : sum local = 2.09244e-10, global = 1.67477e-11, cumulative = 5.75896e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139897, Final residual = 6.86558e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00169038, Final residual = 5.48396e-06, No Iterations 4
ExecutionTime = 24.89 s ClockTime = 25 s
Time = 2.4775
Courant Number mean: 0.134335 max: 0.616713
smoothSolver: Solving for Ux, Initial residual = 0.000788775, Final residual = 3.98465e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241473, Final residual = 4.14578e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00404246, Final residual = 0.00030435, No Iterations 4
time step continuity errors : sum local = 8.48667e-08, global = 6.40938e-09, cumulative = 5.76537e-06
GAMG: Solving for p, Initial residual = 0.000635469, Final residual = 7.86199e-07, No Iterations 16
time step continuity errors : sum local = 2.19224e-10, global = 1.83393e-11, cumulative = 5.76539e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140022, Final residual = 6.88888e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168985, Final residual = 5.49727e-06, No Iterations 4
ExecutionTime = 24.92 s ClockTime = 25 s
Time = 2.48
Courant Number mean: 0.134334 max: 0.616713
smoothSolver: Solving for Ux, Initial residual = 0.000788844, Final residual = 4.00056e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241501, Final residual = 4.1652e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00400687, Final residual = 0.000309127, No Iterations 4
time step continuity errors : sum local = 8.61903e-08, global = 6.30146e-09, cumulative = 5.77169e-06
GAMG: Solving for p, Initial residual = 0.000644055, Final residual = 7.60023e-07, No Iterations 16
time step continuity errors : sum local = 2.11932e-10, global = 1.687e-11, cumulative = 5.77171e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140167, Final residual = 6.90955e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168923, Final residual = 5.50994e-06, No Iterations 4
ExecutionTime = 24.95 s ClockTime = 25 s
Time = 2.4825
Courant Number mean: 0.134342 max: 0.616713
smoothSolver: Solving for Ux, Initial residual = 0.000788876, Final residual = 4.01757e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241502, Final residual = 4.18371e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00381067, Final residual = 0.000310719, No Iterations 4
time step continuity errors : sum local = 8.66329e-08, global = 6.21434e-09, cumulative = 5.77792e-06
GAMG: Solving for p, Initial residual = 0.000629378, Final residual = 6.92078e-07, No Iterations 16
time step continuity errors : sum local = 1.92978e-10, global = 1.48106e-11, cumulative = 5.77794e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014031, Final residual = 6.93375e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168861, Final residual = 5.52371e-06, No Iterations 4
ExecutionTime = 24.97 s ClockTime = 25 s
Time = 2.485
Courant Number mean: 0.134357 max: 0.616713
smoothSolver: Solving for Ux, Initial residual = 0.000788821, Final residual = 4.03507e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241511, Final residual = 4.20281e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00379321, Final residual = 0.000314394, No Iterations 4
time step continuity errors : sum local = 8.76603e-08, global = 6.05569e-09, cumulative = 5.78399e-06
GAMG: Solving for p, Initial residual = 0.000626026, Final residual = 7.0775e-07, No Iterations 16
time step continuity errors : sum local = 1.97372e-10, global = 1.53926e-11, cumulative = 5.78401e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140436, Final residual = 6.95803e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168806, Final residual = 5.53603e-06, No Iterations 4
ExecutionTime = 25 s ClockTime = 25 s
Time = 2.4875
Courant Number mean: 0.134374 max: 0.616713
smoothSolver: Solving for Ux, Initial residual = 0.000788644, Final residual = 4.05274e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241499, Final residual = 4.22224e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00369607, Final residual = 0.000308854, No Iterations 4
time step continuity errors : sum local = 8.61314e-08, global = 6.02132e-09, cumulative = 5.79003e-06
GAMG: Solving for p, Initial residual = 0.000614417, Final residual = 6.87193e-07, No Iterations 16
time step continuity errors : sum local = 1.91681e-10, global = 1.45396e-11, cumulative = 5.79004e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140578, Final residual = 6.98382e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168748, Final residual = 5.55042e-06, No Iterations 4
ExecutionTime = 25.03 s ClockTime = 25 s
Time = 2.49
Courant Number mean: 0.134389 max: 0.616712
smoothSolver: Solving for Ux, Initial residual = 0.000788399, Final residual = 4.07029e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241499, Final residual = 4.24246e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00360832, Final residual = 0.000309324, No Iterations 4
time step continuity errors : sum local = 8.62746e-08, global = 5.95563e-09, cumulative = 5.796e-06
GAMG: Solving for p, Initial residual = 0.000598306, Final residual = 6.77546e-07, No Iterations 16
time step continuity errors : sum local = 1.89016e-10, global = 1.4243e-11, cumulative = 5.79601e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140724, Final residual = 7.00656e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168677, Final residual = 5.56346e-06, No Iterations 4
ExecutionTime = 25.06 s ClockTime = 25 s
Time = 2.4925
Courant Number mean: 0.134403 max: 0.616712
smoothSolver: Solving for Ux, Initial residual = 0.000788377, Final residual = 4.08871e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241484, Final residual = 4.26285e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00374004, Final residual = 0.000308573, No Iterations 4
time step continuity errors : sum local = 8.6095e-08, global = 5.68607e-09, cumulative = 5.8017e-06
GAMG: Solving for p, Initial residual = 0.000596169, Final residual = 8.99909e-07, No Iterations 16
time step continuity errors : sum local = 2.51149e-10, global = 2.33383e-11, cumulative = 5.80172e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014086, Final residual = 7.03005e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168605, Final residual = 5.57654e-06, No Iterations 4
ExecutionTime = 25.08 s ClockTime = 25 s
Time = 2.495
Courant Number mean: 0.134415 max: 0.616712
smoothSolver: Solving for Ux, Initial residual = 0.000788528, Final residual = 4.10693e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241513, Final residual = 4.2826e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00376481, Final residual = 0.000308105, No Iterations 4
time step continuity errors : sum local = 8.59631e-08, global = 5.60643e-09, cumulative = 5.80733e-06
GAMG: Solving for p, Initial residual = 0.000605783, Final residual = 8.34517e-07, No Iterations 16
time step continuity errors : sum local = 2.32806e-10, global = 2.03474e-11, cumulative = 5.80735e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140963, Final residual = 7.05624e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168548, Final residual = 5.58925e-06, No Iterations 4
ExecutionTime = 25.11 s ClockTime = 25 s
Time = 2.4975
Courant Number mean: 0.134425 max: 0.616712
smoothSolver: Solving for Ux, Initial residual = 0.00078882, Final residual = 4.12536e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241505, Final residual = 4.30253e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00390156, Final residual = 0.000304844, No Iterations 4
time step continuity errors : sum local = 8.50113e-08, global = 5.14836e-09, cumulative = 5.8125e-06
GAMG: Solving for p, Initial residual = 0.000607375, Final residual = 7.99166e-07, No Iterations 16
time step continuity errors : sum local = 2.22823e-10, global = 1.92777e-11, cumulative = 5.81252e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141072, Final residual = 7.07243e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168497, Final residual = 5.60379e-06, No Iterations 4
ExecutionTime = 25.13 s ClockTime = 25 s
Time = 2.5
Courant Number mean: 0.134433 max: 0.616712
smoothSolver: Solving for Ux, Initial residual = 0.000789146, Final residual = 4.14428e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241486, Final residual = 4.32215e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00383907, Final residual = 0.000302796, No Iterations 4
time step continuity errors : sum local = 8.44156e-08, global = 5.10464e-09, cumulative = 5.81762e-06
GAMG: Solving for p, Initial residual = 0.000606547, Final residual = 8.49209e-07, No Iterations 16
time step continuity errors : sum local = 2.36758e-10, global = 2.14441e-11, cumulative = 5.81764e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141172, Final residual = 7.09618e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168439, Final residual = 5.61869e-06, No Iterations 4
ExecutionTime = 25.18 s ClockTime = 25 s
Time = 2.5025
Courant Number mean: 0.13444 max: 0.616712
smoothSolver: Solving for Ux, Initial residual = 0.000789478, Final residual = 4.16328e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241474, Final residual = 4.34196e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00375726, Final residual = 0.000302983, No Iterations 4
time step continuity errors : sum local = 8.44672e-08, global = 5.07931e-09, cumulative = 5.82272e-06
GAMG: Solving for p, Initial residual = 0.000606473, Final residual = 8.67821e-07, No Iterations 16
time step continuity errors : sum local = 2.41974e-10, global = 2.22827e-11, cumulative = 5.82274e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141272, Final residual = 7.12158e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168382, Final residual = 5.63343e-06, No Iterations 4
ExecutionTime = 25.2 s ClockTime = 25 s
Time = 2.505
Courant Number mean: 0.134444 max: 0.616712
smoothSolver: Solving for Ux, Initial residual = 0.00078975, Final residual = 4.18196e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241452, Final residual = 4.36183e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00367151, Final residual = 0.000304011, No Iterations 4
time step continuity errors : sum local = 8.47567e-08, global = 5.07786e-09, cumulative = 5.82782e-06
GAMG: Solving for p, Initial residual = 0.000610863, Final residual = 8.40804e-07, No Iterations 16
time step continuity errors : sum local = 2.34412e-10, global = 2.11846e-11, cumulative = 5.82784e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141367, Final residual = 7.14701e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168321, Final residual = 5.64877e-06, No Iterations 4
ExecutionTime = 25.23 s ClockTime = 25 s
Time = 2.5075
Courant Number mean: 0.134446 max: 0.616711
smoothSolver: Solving for Ux, Initial residual = 0.000790027, Final residual = 4.20202e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241463, Final residual = 4.38072e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0036238, Final residual = 0.000301731, No Iterations 4
time step continuity errors : sum local = 8.41401e-08, global = 4.92815e-09, cumulative = 5.83277e-06
GAMG: Solving for p, Initial residual = 0.000602106, Final residual = 8.75709e-07, No Iterations 16
time step continuity errors : sum local = 2.44205e-10, global = 2.27341e-11, cumulative = 5.83279e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141461, Final residual = 7.17385e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168263, Final residual = 5.664e-06, No Iterations 4
ExecutionTime = 25.25 s ClockTime = 25 s
Time = 2.51
Courant Number mean: 0.134447 max: 0.616711
smoothSolver: Solving for Ux, Initial residual = 0.000790181, Final residual = 4.22216e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241473, Final residual = 4.39926e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00355582, Final residual = 0.000295859, No Iterations 4
time step continuity errors : sum local = 8.24891e-08, global = 5.01918e-09, cumulative = 5.83781e-06
GAMG: Solving for p, Initial residual = 0.000598363, Final residual = 7.98946e-07, No Iterations 16
time step continuity errors : sum local = 2.22755e-10, global = 1.96226e-11, cumulative = 5.83783e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141567, Final residual = 7.19988e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168211, Final residual = 5.68394e-06, No Iterations 4
ExecutionTime = 25.27 s ClockTime = 25 s
Time = 2.5125
Courant Number mean: 0.134446 max: 0.616711
smoothSolver: Solving for Ux, Initial residual = 0.000790282, Final residual = 4.2428e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241428, Final residual = 4.41963e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00359402, Final residual = 0.000292991, No Iterations 4
time step continuity errors : sum local = 8.16739e-08, global = 4.91662e-09, cumulative = 5.84275e-06
GAMG: Solving for p, Initial residual = 0.000595643, Final residual = 8.17443e-07, No Iterations 16
time step continuity errors : sum local = 2.27874e-10, global = 2.06713e-11, cumulative = 5.84277e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141662, Final residual = 7.23016e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168159, Final residual = 5.69882e-06, No Iterations 4
ExecutionTime = 25.29 s ClockTime = 25 s
Time = 2.515
Courant Number mean: 0.134444 max: 0.616711
smoothSolver: Solving for Ux, Initial residual = 0.00079041, Final residual = 4.26293e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241414, Final residual = 4.43915e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00370834, Final residual = 0.000290593, No Iterations 4
time step continuity errors : sum local = 8.09781e-08, global = 4.9728e-09, cumulative = 5.84774e-06
GAMG: Solving for p, Initial residual = 0.000598012, Final residual = 8.30458e-07, No Iterations 16
time step continuity errors : sum local = 2.31387e-10, global = 2.0964e-11, cumulative = 5.84776e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141779, Final residual = 7.25423e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168111, Final residual = 5.71423e-06, No Iterations 4
ExecutionTime = 25.31 s ClockTime = 26 s
Time = 2.5175
Courant Number mean: 0.134441 max: 0.616711
smoothSolver: Solving for Ux, Initial residual = 0.000790569, Final residual = 4.2828e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0024141, Final residual = 4.46044e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00373873, Final residual = 0.000285377, No Iterations 4
time step continuity errors : sum local = 7.94869e-08, global = 4.93139e-09, cumulative = 5.85269e-06
GAMG: Solving for p, Initial residual = 0.000604204, Final residual = 7.83049e-07, No Iterations 16
time step continuity errors : sum local = 2.18072e-10, global = 1.93438e-11, cumulative = 5.85271e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141901, Final residual = 7.2795e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168062, Final residual = 5.73042e-06, No Iterations 4
ExecutionTime = 25.33 s ClockTime = 26 s
Time = 2.52
Courant Number mean: 0.134436 max: 0.616711
smoothSolver: Solving for Ux, Initial residual = 0.000790731, Final residual = 4.30279e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241381, Final residual = 4.48192e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00386015, Final residual = 0.000282934, No Iterations 4
time step continuity errors : sum local = 7.87691e-08, global = 4.8632e-09, cumulative = 5.85758e-06
GAMG: Solving for p, Initial residual = 0.000613549, Final residual = 7.5131e-07, No Iterations 16
time step continuity errors : sum local = 2.09138e-10, global = 1.8175e-11, cumulative = 5.8576e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142026, Final residual = 7.30618e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00168022, Final residual = 5.74638e-06, No Iterations 4
ExecutionTime = 25.36 s ClockTime = 26 s
Time = 2.5225
Courant Number mean: 0.134431 max: 0.61671
smoothSolver: Solving for Ux, Initial residual = 0.000790931, Final residual = 4.32357e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241328, Final residual = 4.50361e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0038326, Final residual = 0.000283426, No Iterations 4
time step continuity errors : sum local = 7.88721e-08, global = 4.85547e-09, cumulative = 5.86245e-06
GAMG: Solving for p, Initial residual = 0.000616642, Final residual = 6.98698e-07, No Iterations 16
time step continuity errors : sum local = 1.94415e-10, global = 1.57196e-11, cumulative = 5.86247e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142157, Final residual = 7.33268e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167971, Final residual = 5.76349e-06, No Iterations 4
ExecutionTime = 25.38 s ClockTime = 26 s
Time = 2.525
Courant Number mean: 0.134425 max: 0.61671
smoothSolver: Solving for Ux, Initial residual = 0.000791014, Final residual = 4.3457e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241245, Final residual = 4.52393e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00390547, Final residual = 0.00027524, No Iterations 4
time step continuity errors : sum local = 7.65683e-08, global = 4.26809e-09, cumulative = 5.86673e-06
GAMG: Solving for p, Initial residual = 0.000628752, Final residual = 8.85023e-07, No Iterations 17
time step continuity errors : sum local = 2.46193e-10, global = -4.87144e-11, cumulative = 5.86669e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142265, Final residual = 7.35803e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167908, Final residual = 5.77966e-06, No Iterations 4
ExecutionTime = 25.41 s ClockTime = 26 s
Time = 2.5275
Courant Number mean: 0.134425 max: 0.61671
smoothSolver: Solving for Ux, Initial residual = 0.000790981, Final residual = 4.36628e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241295, Final residual = 4.54876e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00388425, Final residual = 0.000277445, No Iterations 4
time step continuity errors : sum local = 7.7182e-08, global = 4.21977e-09, cumulative = 5.87091e-06
GAMG: Solving for p, Initial residual = 0.000635579, Final residual = 7.05158e-07, No Iterations 16
time step continuity errors : sum local = 1.96202e-10, global = 1.6652e-11, cumulative = 5.87092e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142413, Final residual = 7.38417e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167853, Final residual = 5.79711e-06, No Iterations 4
ExecutionTime = 25.43 s ClockTime = 26 s
Time = 2.53
Courant Number mean: 0.134436 max: 0.61671
smoothSolver: Solving for Ux, Initial residual = 0.000790923, Final residual = 4.38858e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241268, Final residual = 4.5703e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00371561, Final residual = 0.000278738, No Iterations 4
time step continuity errors : sum local = 7.75523e-08, global = 3.43399e-09, cumulative = 5.87436e-06
GAMG: Solving for p, Initial residual = 0.000621863, Final residual = 7.69171e-07, No Iterations 16
time step continuity errors : sum local = 2.14036e-10, global = 1.91258e-11, cumulative = 5.87438e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142533, Final residual = 7.41057e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167804, Final residual = 5.81499e-06, No Iterations 4
ExecutionTime = 25.45 s ClockTime = 26 s
Time = 2.5325
Courant Number mean: 0.134449 max: 0.61671
smoothSolver: Solving for Ux, Initial residual = 0.000790854, Final residual = 4.4107e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241257, Final residual = 4.59242e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00371348, Final residual = 0.000279438, No Iterations 4
time step continuity errors : sum local = 7.77597e-08, global = 3.23957e-09, cumulative = 5.87762e-06
GAMG: Solving for p, Initial residual = 0.00061928, Final residual = 7.34414e-07, No Iterations 16
time step continuity errors : sum local = 2.04413e-10, global = 1.78494e-11, cumulative = 5.87763e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142629, Final residual = 7.43441e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167748, Final residual = 5.83378e-06, No Iterations 4
ExecutionTime = 25.47 s ClockTime = 26 s
Time = 2.535
Courant Number mean: 0.134462 max: 0.61671
smoothSolver: Solving for Ux, Initial residual = 0.000790825, Final residual = 4.43305e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241245, Final residual = 4.61438e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00374853, Final residual = 0.000283182, No Iterations 4
time step continuity errors : sum local = 7.88174e-08, global = 3.18193e-09, cumulative = 5.88082e-06
GAMG: Solving for p, Initial residual = 0.000619776, Final residual = 6.95408e-07, No Iterations 16
time step continuity errors : sum local = 1.93583e-10, global = 1.62181e-11, cumulative = 5.88083e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142705, Final residual = 7.46087e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167682, Final residual = 5.85401e-06, No Iterations 4
ExecutionTime = 25.5 s ClockTime = 26 s
Time = 2.5375
Courant Number mean: 0.134476 max: 0.616709
smoothSolver: Solving for Ux, Initial residual = 0.000791159, Final residual = 4.45575e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241212, Final residual = 4.63584e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00387157, Final residual = 0.000278974, No Iterations 4
time step continuity errors : sum local = 7.76498e-08, global = 2.93453e-09, cumulative = 5.88377e-06
GAMG: Solving for p, Initial residual = 0.00061157, Final residual = 9.06582e-07, No Iterations 16
time step continuity errors : sum local = 2.52362e-10, global = 2.82223e-11, cumulative = 5.88379e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142774, Final residual = 7.49152e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167612, Final residual = 5.8721e-06, No Iterations 4
ExecutionTime = 25.52 s ClockTime = 26 s
Time = 2.54
Courant Number mean: 0.134487 max: 0.616709
smoothSolver: Solving for Ux, Initial residual = 0.000791458, Final residual = 4.47689e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241267, Final residual = 4.66036e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00392078, Final residual = 0.00028371, No Iterations 4
time step continuity errors : sum local = 7.89476e-08, global = 2.73743e-09, cumulative = 5.88653e-06
GAMG: Solving for p, Initial residual = 0.000613748, Final residual = 6.83615e-07, No Iterations 16
time step continuity errors : sum local = 1.90173e-10, global = 1.62756e-11, cumulative = 5.88655e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142876, Final residual = 7.51985e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167549, Final residual = 5.89255e-06, No Iterations 4
ExecutionTime = 25.55 s ClockTime = 26 s
Time = 2.5425
Courant Number mean: 0.134496 max: 0.616709
smoothSolver: Solving for Ux, Initial residual = 0.000792021, Final residual = 4.49986e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241226, Final residual = 4.68213e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00378283, Final residual = 0.000285042, No Iterations 4
time step continuity errors : sum local = 7.92747e-08, global = 2.50626e-09, cumulative = 5.88905e-06
GAMG: Solving for p, Initial residual = 0.000605902, Final residual = 6.84342e-07, No Iterations 16
time step continuity errors : sum local = 1.9031e-10, global = 1.62418e-11, cumulative = 5.88907e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142994, Final residual = 7.54801e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167497, Final residual = 5.9113e-06, No Iterations 4
ExecutionTime = 25.57 s ClockTime = 26 s
Time = 2.545
Courant Number mean: 0.134503 max: 0.616709
smoothSolver: Solving for Ux, Initial residual = 0.000792413, Final residual = 4.52323e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241235, Final residual = 4.70457e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0037025, Final residual = 0.000287758, No Iterations 4
time step continuity errors : sum local = 7.99994e-08, global = 2.10108e-09, cumulative = 5.89117e-06
GAMG: Solving for p, Initial residual = 0.000598833, Final residual = 5.97847e-07, No Iterations 16
time step continuity errors : sum local = 1.66194e-10, global = 1.31229e-11, cumulative = 5.89118e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143114, Final residual = 7.57561e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167442, Final residual = 5.92976e-06, No Iterations 4
ExecutionTime = 25.59 s ClockTime = 26 s
Time = 2.5475
Courant Number mean: 0.134508 max: 0.616709
smoothSolver: Solving for Ux, Initial residual = 0.000792795, Final residual = 4.54715e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241233, Final residual = 4.7268e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00363065, Final residual = 0.000289126, No Iterations 4
time step continuity errors : sum local = 8.03581e-08, global = 1.87536e-09, cumulative = 5.89306e-06
GAMG: Solving for p, Initial residual = 0.000597759, Final residual = 6.06217e-07, No Iterations 16
time step continuity errors : sum local = 1.68477e-10, global = 1.39996e-11, cumulative = 5.89307e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014323, Final residual = 7.60572e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167383, Final residual = 5.94911e-06, No Iterations 4
ExecutionTime = 25.61 s ClockTime = 26 s
Time = 2.55
Courant Number mean: 0.134512 max: 0.616709
smoothSolver: Solving for Ux, Initial residual = 0.000793017, Final residual = 4.5714e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241262, Final residual = 4.74895e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.003541, Final residual = 0.000292666, No Iterations 4
time step continuity errors : sum local = 8.13167e-08, global = 1.80831e-09, cumulative = 5.89488e-06
GAMG: Solving for p, Initial residual = 0.000595866, Final residual = 5.81463e-07, No Iterations 16
time step continuity errors : sum local = 1.61549e-10, global = 1.30815e-11, cumulative = 5.8949e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143349, Final residual = 7.6365e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167328, Final residual = 5.96808e-06, No Iterations 4
ExecutionTime = 25.64 s ClockTime = 26 s
Time = 2.5525
Courant Number mean: 0.134513 max: 0.616708
smoothSolver: Solving for Ux, Initial residual = 0.000793165, Final residual = 4.5954e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241259, Final residual = 4.77067e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00348424, Final residual = 0.000296438, No Iterations 4
time step continuity errors : sum local = 8.23468e-08, global = 1.74611e-09, cumulative = 5.89664e-06
GAMG: Solving for p, Initial residual = 0.000594932, Final residual = 5.60945e-07, No Iterations 16
time step continuity errors : sum local = 1.55815e-10, global = 1.23611e-11, cumulative = 5.89665e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143476, Final residual = 7.66476e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167284, Final residual = 5.98778e-06, No Iterations 4
ExecutionTime = 25.66 s ClockTime = 26 s
Time = 2.555
Courant Number mean: 0.134512 max: 0.616708
smoothSolver: Solving for Ux, Initial residual = 0.000793351, Final residual = 4.6199e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241274, Final residual = 4.79246e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00346332, Final residual = 0.000299403, No Iterations 4
time step continuity errors : sum local = 8.31399e-08, global = 1.63514e-09, cumulative = 5.89829e-06
GAMG: Solving for p, Initial residual = 0.000594317, Final residual = 5.42527e-07, No Iterations 16
time step continuity errors : sum local = 1.50641e-10, global = 1.18069e-11, cumulative = 5.8983e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143597, Final residual = 7.69325e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167246, Final residual = 6.00766e-06, No Iterations 4
ExecutionTime = 25.68 s ClockTime = 26 s
Time = 2.5575
Courant Number mean: 0.134509 max: 0.616708
smoothSolver: Solving for Ux, Initial residual = 0.000793441, Final residual = 4.64435e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241293, Final residual = 4.81367e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00344964, Final residual = 0.000302478, No Iterations 4
time step continuity errors : sum local = 8.39867e-08, global = 1.15772e-09, cumulative = 5.89946e-06
GAMG: Solving for p, Initial residual = 0.000595142, Final residual = 5.98285e-07, No Iterations 15
time step continuity errors : sum local = 1.6612e-10, global = 1.14941e-11, cumulative = 5.89947e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143712, Final residual = 7.72302e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167201, Final residual = 6.02778e-06, No Iterations 4
ExecutionTime = 25.7 s ClockTime = 26 s
Time = 2.56
Courant Number mean: 0.134505 max: 0.616708
smoothSolver: Solving for Ux, Initial residual = 0.00079343, Final residual = 4.66806e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241293, Final residual = 4.8346e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00369656, Final residual = 0.000304922, No Iterations 4
time step continuity errors : sum local = 8.46379e-08, global = 1.09191e-09, cumulative = 5.90056e-06
GAMG: Solving for p, Initial residual = 0.000607586, Final residual = 6.2566e-07, No Iterations 15
time step continuity errors : sum local = 1.73646e-10, global = 1.17118e-11, cumulative = 5.90057e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143811, Final residual = 7.75324e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167155, Final residual = 6.04782e-06, No Iterations 4
ExecutionTime = 25.72 s ClockTime = 26 s
Time = 2.5625
Courant Number mean: 0.134499 max: 0.616708
smoothSolver: Solving for Ux, Initial residual = 0.000793512, Final residual = 4.69208e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241271, Final residual = 4.85707e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00382228, Final residual = 0.00030777, No Iterations 4
time step continuity errors : sum local = 8.53728e-08, global = 8.25584e-10, cumulative = 5.9014e-06
GAMG: Solving for p, Initial residual = 0.000622672, Final residual = 7.59345e-07, No Iterations 15
time step continuity errors : sum local = 2.10571e-10, global = 1.56487e-11, cumulative = 5.90141e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143916, Final residual = 7.78228e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167118, Final residual = 6.06765e-06, No Iterations 4
ExecutionTime = 25.75 s ClockTime = 26 s
Time = 2.565
Courant Number mean: 0.134492 max: 0.616708
smoothSolver: Solving for Ux, Initial residual = 0.000793598, Final residual = 4.71588e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0024123, Final residual = 4.88022e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00374936, Final residual = 0.000309968, No Iterations 4
time step continuity errors : sum local = 8.5923e-08, global = 8.10601e-10, cumulative = 5.90223e-06
GAMG: Solving for p, Initial residual = 0.000622322, Final residual = 7.48071e-07, No Iterations 15
time step continuity errors : sum local = 2.07331e-10, global = 1.51537e-11, cumulative = 5.90224e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144004, Final residual = 7.80928e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167071, Final residual = 6.08733e-06, No Iterations 4
ExecutionTime = 25.77 s ClockTime = 26 s
Time = 2.5675
Courant Number mean: 0.134484 max: 0.616708
smoothSolver: Solving for Ux, Initial residual = 0.000793722, Final residual = 4.74096e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241156, Final residual = 4.90494e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00372912, Final residual = 0.000311485, No Iterations 4
time step continuity errors : sum local = 8.6302e-08, global = 8.62736e-10, cumulative = 5.9031e-06
GAMG: Solving for p, Initial residual = 0.00061966, Final residual = 6.9736e-07, No Iterations 15
time step continuity errors : sum local = 1.93195e-10, global = 1.33955e-11, cumulative = 5.90312e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144097, Final residual = 7.83926e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00167011, Final residual = 6.1084e-06, No Iterations 4
ExecutionTime = 25.79 s ClockTime = 26 s
Time = 2.57
Courant Number mean: 0.134475 max: 0.616707
smoothSolver: Solving for Ux, Initial residual = 0.000793832, Final residual = 4.76617e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241094, Final residual = 4.93008e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00370828, Final residual = 0.000315112, No Iterations 4
time step continuity errors : sum local = 8.72656e-08, global = 6.99867e-10, cumulative = 5.90382e-06
GAMG: Solving for p, Initial residual = 0.000616933, Final residual = 7.59175e-07, No Iterations 15
time step continuity errors : sum local = 2.10214e-10, global = 1.52471e-11, cumulative = 5.90383e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144187, Final residual = 7.87002e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166948, Final residual = 6.12943e-06, No Iterations 4
ExecutionTime = 25.81 s ClockTime = 26 s
Time = 2.5725
Courant Number mean: 0.13447 max: 0.616707
smoothSolver: Solving for Ux, Initial residual = 0.000793821, Final residual = 4.79181e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241046, Final residual = 4.95561e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00363072, Final residual = 0.000318154, No Iterations 4
time step continuity errors : sum local = 8.80617e-08, global = 2.79054e-10, cumulative = 5.90411e-06
GAMG: Solving for p, Initial residual = 0.000619932, Final residual = 7.95679e-07, No Iterations 15
time step continuity errors : sum local = 2.20204e-10, global = 1.63736e-11, cumulative = 5.90413e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014429, Final residual = 7.90298e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166889, Final residual = 6.15095e-06, No Iterations 4
ExecutionTime = 25.84 s ClockTime = 26 s
Time = 2.575
Courant Number mean: 0.134476 max: 0.616707
smoothSolver: Solving for Ux, Initial residual = 0.000793722, Final residual = 4.81824e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00241022, Final residual = 4.98145e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00359875, Final residual = 0.00032043, No Iterations 4
time step continuity errors : sum local = 8.86418e-08, global = 1.20898e-10, cumulative = 5.90425e-06
GAMG: Solving for p, Initial residual = 0.000623345, Final residual = 8.3212e-07, No Iterations 15
time step continuity errors : sum local = 2.30156e-10, global = 1.75029e-11, cumulative = 5.90427e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144382, Final residual = 7.93278e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166828, Final residual = 6.17351e-06, No Iterations 4
ExecutionTime = 25.86 s ClockTime = 26 s
Time = 2.5775
Courant Number mean: 0.134484 max: 0.616707
smoothSolver: Solving for Ux, Initial residual = 0.000793824, Final residual = 4.84491e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240996, Final residual = 5.00799e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00376789, Final residual = 0.000323487, No Iterations 4
time step continuity errors : sum local = 8.94541e-08, global = 5.42338e-11, cumulative = 5.90432e-06
GAMG: Solving for p, Initial residual = 0.000652904, Final residual = 8.93619e-07, No Iterations 15
time step continuity errors : sum local = 2.47118e-10, global = 1.97333e-11, cumulative = 5.90434e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144483, Final residual = 7.96282e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166771, Final residual = 6.19519e-06, No Iterations 4
ExecutionTime = 25.89 s ClockTime = 26 s
Time = 2.58
Courant Number mean: 0.134493 max: 0.616707
smoothSolver: Solving for Ux, Initial residual = 0.000794289, Final residual = 4.87143e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0024094, Final residual = 5.03432e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00389708, Final residual = 0.000324535, No Iterations 4
time step continuity errors : sum local = 8.97281e-08, global = -6.37122e-11, cumulative = 5.90428e-06
GAMG: Solving for p, Initial residual = 0.000659766, Final residual = 9.13068e-07, No Iterations 15
time step continuity errors : sum local = 2.52456e-10, global = 2.02363e-11, cumulative = 5.9043e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144583, Final residual = 7.99449e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.001667, Final residual = 6.21655e-06, No Iterations 4
ExecutionTime = 25.91 s ClockTime = 26 s
Time = 2.5825
Courant Number mean: 0.134502 max: 0.616707
smoothSolver: Solving for Ux, Initial residual = 0.000794756, Final residual = 4.89776e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240913, Final residual = 5.06052e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00426951, Final residual = 0.000326085, No Iterations 4
time step continuity errors : sum local = 9.01303e-08, global = -1.25754e-10, cumulative = 5.90417e-06
GAMG: Solving for p, Initial residual = 0.000691693, Final residual = 9.01431e-07, No Iterations 15
time step continuity errors : sum local = 2.49138e-10, global = 1.96257e-11, cumulative = 5.90419e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144699, Final residual = 8.02709e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166628, Final residual = 6.23971e-06, No Iterations 4
ExecutionTime = 25.94 s ClockTime = 26 s
Time = 2.585
Courant Number mean: 0.134509 max: 0.616707
smoothSolver: Solving for Ux, Initial residual = 0.000795218, Final residual = 4.92446e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240876, Final residual = 5.08684e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0042308, Final residual = 0.000328529, No Iterations 4
time step continuity errors : sum local = 9.07839e-08, global = -2.79872e-10, cumulative = 5.90391e-06
GAMG: Solving for p, Initial residual = 0.000688237, Final residual = 9.2556e-07, No Iterations 15
time step continuity errors : sum local = 2.55776e-10, global = 2.03156e-11, cumulative = 5.90393e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014482, Final residual = 8.05596e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166572, Final residual = 6.26693e-06, No Iterations 4
ExecutionTime = 25.96 s ClockTime = 26 s
Time = 2.5875
Courant Number mean: 0.134514 max: 0.616707
smoothSolver: Solving for Ux, Initial residual = 0.000795721, Final residual = 4.95131e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240835, Final residual = 5.11365e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00399153, Final residual = 0.000329264, No Iterations 4
time step continuity errors : sum local = 9.09932e-08, global = -3.40049e-10, cumulative = 5.90359e-06
GAMG: Solving for p, Initial residual = 0.000670866, Final residual = 9.35503e-07, No Iterations 15
time step continuity errors : sum local = 2.58535e-10, global = 2.08788e-11, cumulative = 5.90361e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144915, Final residual = 8.0894e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166517, Final residual = 6.28992e-06, No Iterations 4
ExecutionTime = 25.98 s ClockTime = 26 s
Time = 2.59
Courant Number mean: 0.134517 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.000796121, Final residual = 4.97897e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240823, Final residual = 5.13952e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.003937, Final residual = 0.000327527, No Iterations 4
time step continuity errors : sum local = 9.04856e-08, global = -5.90712e-10, cumulative = 5.90302e-06
GAMG: Solving for p, Initial residual = 0.000666301, Final residual = 8.90452e-07, No Iterations 15
time step continuity errors : sum local = 2.45985e-10, global = 1.89745e-11, cumulative = 5.90304e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145029, Final residual = 8.11022e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166463, Final residual = 6.31353e-06, No Iterations 4
ExecutionTime = 26.01 s ClockTime = 26 s
Time = 2.5925
Courant Number mean: 0.134518 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.000796451, Final residual = 5.00691e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240848, Final residual = 5.16559e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0038363, Final residual = 0.000334267, No Iterations 4
time step continuity errors : sum local = 9.23235e-08, global = -1.58081e-09, cumulative = 5.90146e-06
GAMG: Solving for p, Initial residual = 0.000670338, Final residual = 5.53121e-07, No Iterations 17
time step continuity errors : sum local = 1.52766e-10, global = 1.3311e-11, cumulative = 5.90147e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145135, Final residual = 8.14635e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166411, Final residual = 6.33672e-06, No Iterations 4
ExecutionTime = 26.03 s ClockTime = 26 s
Time = 2.595
Courant Number mean: 0.134518 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.000796809, Final residual = 5.03601e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.002408, Final residual = 5.18893e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00365839, Final residual = 0.000326018, No Iterations 4
time step continuity errors : sum local = 9.00275e-08, global = -5.89958e-10, cumulative = 5.90088e-06
GAMG: Solving for p, Initial residual = 0.000648489, Final residual = 9.84312e-07, No Iterations 15
time step continuity errors : sum local = 2.71805e-10, global = 2.28256e-11, cumulative = 5.9009e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014522, Final residual = 8.17816e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166369, Final residual = 6.36438e-06, No Iterations 4
ExecutionTime = 26.06 s ClockTime = 26 s
Time = 2.5975
Courant Number mean: 0.134515 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.000796943, Final residual = 5.06209e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240906, Final residual = 5.21799e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00370956, Final residual = 0.000333468, No Iterations 4
time step continuity errors : sum local = 9.20529e-08, global = -1.75543e-09, cumulative = 5.89915e-06
GAMG: Solving for p, Initial residual = 0.000659162, Final residual = 6.00242e-07, No Iterations 17
time step continuity errors : sum local = 1.65671e-10, global = 1.53086e-11, cumulative = 5.89916e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145296, Final residual = 8.21296e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166336, Final residual = 6.38853e-06, No Iterations 4
ExecutionTime = 26.08 s ClockTime = 26 s
Time = 2.6
Courant Number mean: 0.13451 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.00079715, Final residual = 5.09123e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240949, Final residual = 5.2427e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0036584, Final residual = 0.000332077, No Iterations 4
time step continuity errors : sum local = 9.16493e-08, global = -1.91138e-09, cumulative = 5.89725e-06
GAMG: Solving for p, Initial residual = 0.000657568, Final residual = 6.42817e-07, No Iterations 17
time step continuity errors : sum local = 1.77389e-10, global = 1.71567e-11, cumulative = 5.89727e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145366, Final residual = 8.24663e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166297, Final residual = 6.41308e-06, No Iterations 4
ExecutionTime = 26.13 s ClockTime = 26 s
Time = 2.6025
Courant Number mean: 0.134503 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.000797152, Final residual = 5.11895e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240977, Final residual = 5.26794e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00367247, Final residual = 0.000331837, No Iterations 4
time step continuity errors : sum local = 9.15322e-08, global = -2.06651e-09, cumulative = 5.8952e-06
GAMG: Solving for p, Initial residual = 0.000661135, Final residual = 5.92448e-07, No Iterations 17
time step continuity errors : sum local = 1.63385e-10, global = 1.45185e-11, cumulative = 5.89522e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145463, Final residual = 8.28075e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166243, Final residual = 6.43712e-06, No Iterations 4
ExecutionTime = 26.15 s ClockTime = 26 s
Time = 2.605
Courant Number mean: 0.134494 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.00079712, Final residual = 5.14694e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240955, Final residual = 5.29282e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00362878, Final residual = 0.000333194, No Iterations 4
time step continuity errors : sum local = 9.18453e-08, global = -2.2401e-09, cumulative = 5.89298e-06
GAMG: Solving for p, Initial residual = 0.000660765, Final residual = 6.2047e-07, No Iterations 17
time step continuity errors : sum local = 1.70986e-10, global = 1.55506e-11, cumulative = 5.89299e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145586, Final residual = 8.31424e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0016619, Final residual = 6.46218e-06, No Iterations 4
ExecutionTime = 26.18 s ClockTime = 26 s
Time = 2.6075
Courant Number mean: 0.134483 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.000797159, Final residual = 5.17465e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240888, Final residual = 5.31769e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0036979, Final residual = 0.000332133, No Iterations 4
time step continuity errors : sum local = 9.14843e-08, global = -2.43692e-09, cumulative = 5.89056e-06
GAMG: Solving for p, Initial residual = 0.000665321, Final residual = 6.24336e-07, No Iterations 17
time step continuity errors : sum local = 1.71913e-10, global = 1.55191e-11, cumulative = 5.89057e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145708, Final residual = 8.35036e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166139, Final residual = 6.48544e-06, No Iterations 4
ExecutionTime = 26.2 s ClockTime = 26 s
Time = 2.61
Courant Number mean: 0.134471 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.000797173, Final residual = 5.20351e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240798, Final residual = 5.34428e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0038277, Final residual = 0.000328311, No Iterations 4
time step continuity errors : sum local = 9.03592e-08, global = -2.4823e-09, cumulative = 5.88809e-06
GAMG: Solving for p, Initial residual = 0.000667952, Final residual = 6.96411e-07, No Iterations 17
time step continuity errors : sum local = 1.91596e-10, global = 1.94343e-11, cumulative = 5.88811e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145836, Final residual = 8.38702e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166083, Final residual = 6.51457e-06, No Iterations 4
ExecutionTime = 26.23 s ClockTime = 26 s
Time = 2.6125
Courant Number mean: 0.134458 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.000797093, Final residual = 5.23251e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240731, Final residual = 5.37147e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00367747, Final residual = 0.000326054, No Iterations 4
time step continuity errors : sum local = 8.96757e-08, global = -2.60439e-09, cumulative = 5.88551e-06
GAMG: Solving for p, Initial residual = 0.000661078, Final residual = 6.49658e-07, No Iterations 17
time step continuity errors : sum local = 1.78631e-10, global = 1.66048e-11, cumulative = 5.88552e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145969, Final residual = 8.41703e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00166028, Final residual = 6.54e-06, No Iterations 4
ExecutionTime = 26.25 s ClockTime = 26 s
Time = 2.615
Courant Number mean: 0.134444 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.000797121, Final residual = 5.26251e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240655, Final residual = 5.39888e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00368533, Final residual = 0.0003252, No Iterations 4
time step continuity errors : sum local = 8.93834e-08, global = -2.71367e-09, cumulative = 5.88281e-06
GAMG: Solving for p, Initial residual = 0.000662212, Final residual = 6.48153e-07, No Iterations 17
time step continuity errors : sum local = 1.78101e-10, global = 1.64081e-11, cumulative = 5.88282e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146099, Final residual = 8.45179e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165977, Final residual = 6.565e-06, No Iterations 4
ExecutionTime = 26.28 s ClockTime = 26 s
Time = 2.6175
Courant Number mean: 0.134433 max: 0.616706
smoothSolver: Solving for Ux, Initial residual = 0.000797169, Final residual = 5.29287e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240576, Final residual = 5.42733e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.003609, Final residual = 0.000323704, No Iterations 4
time step continuity errors : sum local = 8.89192e-08, global = -2.78269e-09, cumulative = 5.88004e-06
GAMG: Solving for p, Initial residual = 0.000661197, Final residual = 6.9759e-07, No Iterations 17
time step continuity errors : sum local = 1.91569e-10, global = 1.83226e-11, cumulative = 5.88006e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146222, Final residual = 8.48531e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165929, Final residual = 6.58995e-06, No Iterations 4
ExecutionTime = 26.3 s ClockTime = 27 s
Time = 2.62
Courant Number mean: 0.134433 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000797218, Final residual = 5.32329e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240503, Final residual = 5.45622e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00353448, Final residual = 0.000322679, No Iterations 4
time step continuity errors : sum local = 8.85773e-08, global = -2.8412e-09, cumulative = 5.87722e-06
GAMG: Solving for p, Initial residual = 0.000655289, Final residual = 6.71623e-07, No Iterations 17
time step continuity errors : sum local = 1.84307e-10, global = 1.70774e-11, cumulative = 5.87724e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146312, Final residual = 8.51783e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165878, Final residual = 6.61539e-06, No Iterations 4
ExecutionTime = 26.33 s ClockTime = 27 s
Time = 2.6225
Courant Number mean: 0.134436 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000797538, Final residual = 5.35383e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240435, Final residual = 5.48588e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00366413, Final residual = 0.000321961, No Iterations 4
time step continuity errors : sum local = 8.83242e-08, global = -2.88509e-09, cumulative = 5.87435e-06
GAMG: Solving for p, Initial residual = 0.000671197, Final residual = 6.64284e-07, No Iterations 17
time step continuity errors : sum local = 1.82175e-10, global = 1.66104e-11, cumulative = 5.87437e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146397, Final residual = 8.55098e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165817, Final residual = 6.64126e-06, No Iterations 4
ExecutionTime = 26.35 s ClockTime = 27 s
Time = 2.625
Courant Number mean: 0.134439 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000797993, Final residual = 5.38436e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240338, Final residual = 5.51585e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00379178, Final residual = 0.000318961, No Iterations 4
time step continuity errors : sum local = 8.74618e-08, global = -2.8977e-09, cumulative = 5.87147e-06
GAMG: Solving for p, Initial residual = 0.000696483, Final residual = 7.18005e-07, No Iterations 17
time step continuity errors : sum local = 1.96859e-10, global = 1.92617e-11, cumulative = 5.87149e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014648, Final residual = 8.58654e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165751, Final residual = 6.6676e-06, No Iterations 4
ExecutionTime = 26.37 s ClockTime = 27 s
Time = 2.6275
Courant Number mean: 0.134441 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000798595, Final residual = 5.41493e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240231, Final residual = 5.54632e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00391691, Final residual = 0.00031686, No Iterations 4
time step continuity errors : sum local = 8.68523e-08, global = -3.08361e-09, cumulative = 5.86841e-06
GAMG: Solving for p, Initial residual = 0.000713461, Final residual = 6.59133e-07, No Iterations 17
time step continuity errors : sum local = 1.80631e-10, global = 1.63694e-11, cumulative = 5.86842e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146552, Final residual = 8.6134e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165683, Final residual = 6.69428e-06, No Iterations 4
ExecutionTime = 26.4 s ClockTime = 27 s
Time = 2.63
Courant Number mean: 0.134443 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000799024, Final residual = 5.44613e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240161, Final residual = 5.57632e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00402634, Final residual = 0.000316849, No Iterations 4
time step continuity errors : sum local = 8.6817e-08, global = -3.01024e-09, cumulative = 5.86541e-06
GAMG: Solving for p, Initial residual = 0.000718803, Final residual = 6.59821e-07, No Iterations 17
time step continuity errors : sum local = 1.80787e-10, global = 1.64347e-11, cumulative = 5.86543e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146615, Final residual = 8.64914e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165628, Final residual = 6.72097e-06, No Iterations 4
ExecutionTime = 26.42 s ClockTime = 27 s
Time = 2.6325
Courant Number mean: 0.134443 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000799438, Final residual = 5.47699e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240122, Final residual = 5.60686e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00390501, Final residual = 0.000314289, No Iterations 4
time step continuity errors : sum local = 8.61206e-08, global = -3.07807e-09, cumulative = 5.86235e-06
GAMG: Solving for p, Initial residual = 0.000696885, Final residual = 7.34107e-07, No Iterations 17
time step continuity errors : sum local = 2.01154e-10, global = 1.98335e-11, cumulative = 5.86237e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146675, Final residual = 8.68449e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165571, Final residual = 6.74747e-06, No Iterations 4
ExecutionTime = 26.44 s ClockTime = 27 s
Time = 2.635
Courant Number mean: 0.134441 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000799739, Final residual = 5.50807e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0024017, Final residual = 5.63685e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00396119, Final residual = 0.000316152, No Iterations 4
time step continuity errors : sum local = 8.6602e-08, global = -2.9183e-09, cumulative = 5.85945e-06
GAMG: Solving for p, Initial residual = 0.000708057, Final residual = 7.00381e-07, No Iterations 17
time step continuity errors : sum local = 1.91796e-10, global = 1.78654e-11, cumulative = 5.85947e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146742, Final residual = 8.71933e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0016551, Final residual = 6.77445e-06, No Iterations 4
ExecutionTime = 26.47 s ClockTime = 27 s
Time = 2.6375
Courant Number mean: 0.134437 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000799958, Final residual = 5.54009e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240254, Final residual = 5.66734e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00374897, Final residual = 0.000315683, No Iterations 4
time step continuity errors : sum local = 8.6422e-08, global = -2.96117e-09, cumulative = 5.85651e-06
GAMG: Solving for p, Initial residual = 0.000689676, Final residual = 6.7467e-07, No Iterations 17
time step continuity errors : sum local = 1.84652e-10, global = 1.68529e-11, cumulative = 5.85653e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146827, Final residual = 8.75214e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165469, Final residual = 6.80173e-06, No Iterations 4
ExecutionTime = 26.49 s ClockTime = 27 s
Time = 2.64
Courant Number mean: 0.134431 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000800186, Final residual = 5.57244e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240316, Final residual = 5.69691e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00370354, Final residual = 0.000316321, No Iterations 4
time step continuity errors : sum local = 8.65565e-08, global = -2.82018e-09, cumulative = 5.8537e-06
GAMG: Solving for p, Initial residual = 0.000682509, Final residual = 7.42722e-07, No Iterations 17
time step continuity errors : sum local = 2.03181e-10, global = 2.02426e-11, cumulative = 5.85373e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146923, Final residual = 8.79296e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165427, Final residual = 6.83359e-06, No Iterations 4
ExecutionTime = 26.52 s ClockTime = 27 s
Time = 2.6425
Courant Number mean: 0.134422 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000800345, Final residual = 5.60302e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240356, Final residual = 5.72719e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00374873, Final residual = 0.00031858, No Iterations 4
time step continuity errors : sum local = 8.71217e-08, global = -2.82378e-09, cumulative = 5.8509e-06
GAMG: Solving for p, Initial residual = 0.000685625, Final residual = 7.10369e-07, No Iterations 17
time step continuity errors : sum local = 1.94203e-10, global = 1.82085e-11, cumulative = 5.85092e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147021, Final residual = 8.82348e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165379, Final residual = 6.86184e-06, No Iterations 4
ExecutionTime = 26.55 s ClockTime = 27 s
Time = 2.645
Courant Number mean: 0.134412 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000800418, Final residual = 5.63431e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240351, Final residual = 5.7573e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00366176, Final residual = 0.000319764, No Iterations 4
time step continuity errors : sum local = 8.73773e-08, global = -2.78236e-09, cumulative = 5.84814e-06
GAMG: Solving for p, Initial residual = 0.000679856, Final residual = 7.26506e-07, No Iterations 17
time step continuity errors : sum local = 1.98457e-10, global = 1.88783e-11, cumulative = 5.84816e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147136, Final residual = 8.858e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165324, Final residual = 6.88994e-06, No Iterations 4
ExecutionTime = 26.58 s ClockTime = 27 s
Time = 2.6475
Courant Number mean: 0.1344 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000800331, Final residual = 5.66617e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240312, Final residual = 5.7866e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00371186, Final residual = 0.000322408, No Iterations 4
time step continuity errors : sum local = 8.80577e-08, global = -2.56154e-09, cumulative = 5.84559e-06
GAMG: Solving for p, Initial residual = 0.000688796, Final residual = 7.44392e-07, No Iterations 17
time step continuity errors : sum local = 2.03254e-10, global = 2.01062e-11, cumulative = 5.84561e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147245, Final residual = 8.89328e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165267, Final residual = 6.91826e-06, No Iterations 4
ExecutionTime = 26.61 s ClockTime = 27 s
Time = 2.65
Courant Number mean: 0.134386 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000800245, Final residual = 5.69849e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240238, Final residual = 5.81685e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00376389, Final residual = 0.000322812, No Iterations 4
time step continuity errors : sum local = 8.80959e-08, global = -2.51901e-09, cumulative = 5.8431e-06
GAMG: Solving for p, Initial residual = 0.000697682, Final residual = 7.16956e-07, No Iterations 17
time step continuity errors : sum local = 1.95577e-10, global = 1.85263e-11, cumulative = 5.84311e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147349, Final residual = 8.93031e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165213, Final residual = 6.94635e-06, No Iterations 4
ExecutionTime = 26.65 s ClockTime = 27 s
Time = 2.6525
Courant Number mean: 0.134371 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.000800244, Final residual = 5.73171e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240133, Final residual = 5.84718e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00381695, Final residual = 0.000323148, No Iterations 4
time step continuity errors : sum local = 8.81068e-08, global = -2.57859e-09, cumulative = 5.84054e-06
GAMG: Solving for p, Initial residual = 0.000698339, Final residual = 7.68664e-07, No Iterations 17
time step continuity errors : sum local = 2.095e-10, global = 2.05289e-11, cumulative = 5.84056e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147456, Final residual = 8.96591e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165149, Final residual = 6.97633e-06, No Iterations 4
ExecutionTime = 26.68 s ClockTime = 27 s
Time = 2.655
Courant Number mean: 0.134354 max: 0.616705
smoothSolver: Solving for Ux, Initial residual = 0.00080024, Final residual = 5.76552e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00240017, Final residual = 5.87867e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00379245, Final residual = 0.000324529, No Iterations 4
time step continuity errors : sum local = 8.84333e-08, global = -2.60277e-09, cumulative = 5.83795e-06
GAMG: Solving for p, Initial residual = 0.000695631, Final residual = 8.03174e-07, No Iterations 17
time step continuity errors : sum local = 2.18814e-10, global = 2.18838e-11, cumulative = 5.83798e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147546, Final residual = 9.0004e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165085, Final residual = 7.00473e-06, No Iterations 4
ExecutionTime = 26.7 s ClockTime = 27 s
Time = 2.6575
Courant Number mean: 0.134337 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.000800224, Final residual = 5.80029e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239904, Final residual = 5.91038e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00375443, Final residual = 0.000328366, No Iterations 4
time step continuity errors : sum local = 8.94224e-08, global = -2.39985e-09, cumulative = 5.83558e-06
GAMG: Solving for p, Initial residual = 0.0006985, Final residual = 7.73317e-07, No Iterations 17
time step continuity errors : sum local = 2.10525e-10, global = 2.07872e-11, cumulative = 5.8356e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147618, Final residual = 9.03708e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00165027, Final residual = 7.03317e-06, No Iterations 4
ExecutionTime = 26.73 s ClockTime = 27 s
Time = 2.66
Courant Number mean: 0.134319 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.000800421, Final residual = 5.83537e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023981, Final residual = 5.9426e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0036458, Final residual = 0.000330645, No Iterations 4
time step continuity errors : sum local = 8.99917e-08, global = -2.47524e-09, cumulative = 5.83312e-06
GAMG: Solving for p, Initial residual = 0.000697764, Final residual = 7.87003e-07, No Iterations 17
time step continuity errors : sum local = 2.14149e-10, global = 2.11484e-11, cumulative = 5.83314e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147681, Final residual = 9.07361e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164972, Final residual = 7.06262e-06, No Iterations 4
ExecutionTime = 26.76 s ClockTime = 27 s
Time = 2.6625
Courant Number mean: 0.134306 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.00080076, Final residual = 5.87082e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239748, Final residual = 5.97482e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00358295, Final residual = 0.000330038, No Iterations 4
time step continuity errors : sum local = 8.97781e-08, global = -2.51328e-09, cumulative = 5.83063e-06
GAMG: Solving for p, Initial residual = 0.00069408, Final residual = 7.69589e-07, No Iterations 17
time step continuity errors : sum local = 2.09292e-10, global = 2.02946e-11, cumulative = 5.83065e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147731, Final residual = 9.11278e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164912, Final residual = 7.09003e-06, No Iterations 4
ExecutionTime = 26.79 s ClockTime = 27 s
Time = 2.665
Courant Number mean: 0.134301 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.000801208, Final residual = 5.90658e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239648, Final residual = 6.00794e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00396915, Final residual = 0.000328399, No Iterations 4
time step continuity errors : sum local = 8.92819e-08, global = -2.62652e-09, cumulative = 5.82802e-06
GAMG: Solving for p, Initial residual = 0.000729749, Final residual = 7.62785e-07, No Iterations 17
time step continuity errors : sum local = 2.07333e-10, global = 1.96763e-11, cumulative = 5.82804e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147801, Final residual = 9.15049e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164847, Final residual = 7.11974e-06, No Iterations 4
ExecutionTime = 26.82 s ClockTime = 27 s
Time = 2.6675
Courant Number mean: 0.134298 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.000801558, Final residual = 5.94267e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239572, Final residual = 6.04135e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00395274, Final residual = 0.000330991, No Iterations 4
time step continuity errors : sum local = 8.99325e-08, global = -2.65664e-09, cumulative = 5.82539e-06
GAMG: Solving for p, Initial residual = 0.000735003, Final residual = 7.16247e-07, No Iterations 17
time step continuity errors : sum local = 1.94548e-10, global = 1.76349e-11, cumulative = 5.8254e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147888, Final residual = 9.18658e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164769, Final residual = 7.14973e-06, No Iterations 4
ExecutionTime = 26.84 s ClockTime = 27 s
Time = 2.67
Courant Number mean: 0.134295 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.000801934, Final residual = 5.97952e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239453, Final residual = 6.07418e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00381779, Final residual = 0.000324621, No Iterations 4
time step continuity errors : sum local = 8.81496e-08, global = -2.4185e-09, cumulative = 5.82298e-06
GAMG: Solving for p, Initial residual = 0.000729262, Final residual = 9.68227e-07, No Iterations 17
time step continuity errors : sum local = 2.62867e-10, global = 3.19595e-11, cumulative = 5.82302e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147972, Final residual = 9.22942e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164687, Final residual = 7.1794e-06, No Iterations 4
ExecutionTime = 26.87 s ClockTime = 27 s
Time = 2.6725
Courant Number mean: 0.134292 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.000802187, Final residual = 6.01403e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239437, Final residual = 6.11252e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00392094, Final residual = 0.000326437, No Iterations 4
time step continuity errors : sum local = 8.86033e-08, global = -2.88186e-09, cumulative = 5.82013e-06
GAMG: Solving for p, Initial residual = 0.00074391, Final residual = 8.23967e-07, No Iterations 17
time step continuity errors : sum local = 2.236e-10, global = 2.23238e-11, cumulative = 5.82016e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148064, Final residual = 9.26283e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164616, Final residual = 7.21034e-06, No Iterations 4
ExecutionTime = 26.9 s ClockTime = 27 s
Time = 2.675
Courant Number mean: 0.134287 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.000802395, Final residual = 6.0512e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239379, Final residual = 6.14631e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00396168, Final residual = 0.000326477, No Iterations 4
time step continuity errors : sum local = 8.85802e-08, global = -2.92177e-09, cumulative = 5.81724e-06
GAMG: Solving for p, Initial residual = 0.000759976, Final residual = 8.502e-07, No Iterations 17
time step continuity errors : sum local = 2.30658e-10, global = 2.3564e-11, cumulative = 5.81726e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148155, Final residual = 9.30636e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164551, Final residual = 7.2407e-06, No Iterations 4
ExecutionTime = 26.92 s ClockTime = 27 s
Time = 2.6775
Courant Number mean: 0.134281 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.000802555, Final residual = 6.08824e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239414, Final residual = 6.18167e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00394495, Final residual = 0.000325108, No Iterations 4
time step continuity errors : sum local = 8.82255e-08, global = -3.15513e-09, cumulative = 5.8141e-06
GAMG: Solving for p, Initial residual = 0.000759595, Final residual = 9.32711e-07, No Iterations 17
time step continuity errors : sum local = 2.53126e-10, global = 2.87272e-11, cumulative = 5.81413e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148248, Final residual = 9.34513e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164494, Final residual = 7.27574e-06, No Iterations 4
ExecutionTime = 26.95 s ClockTime = 27 s
Time = 2.68
Courant Number mean: 0.134274 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.000802718, Final residual = 6.12544e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239449, Final residual = 6.21558e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00382494, Final residual = 0.000323662, No Iterations 4
time step continuity errors : sum local = 8.78103e-08, global = -3.38676e-09, cumulative = 5.81075e-06
GAMG: Solving for p, Initial residual = 0.000755508, Final residual = 8.62965e-07, No Iterations 17
time step continuity errors : sum local = 2.34074e-10, global = 2.38752e-11, cumulative = 5.81077e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148327, Final residual = 9.38143e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164443, Final residual = 7.3061e-06, No Iterations 4
ExecutionTime = 26.98 s ClockTime = 27 s
Time = 2.6825
Courant Number mean: 0.134264 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.00080282, Final residual = 6.16338e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239466, Final residual = 6.24982e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00386845, Final residual = 0.000321782, No Iterations 4
time step continuity errors : sum local = 8.72515e-08, global = -3.53596e-09, cumulative = 5.80723e-06
GAMG: Solving for p, Initial residual = 0.000746971, Final residual = 8.67406e-07, No Iterations 17
time step continuity errors : sum local = 2.35132e-10, global = 2.3783e-11, cumulative = 5.80726e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014839, Final residual = 9.42238e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164395, Final residual = 7.33849e-06, No Iterations 4
ExecutionTime = 27.01 s ClockTime = 27 s
Time = 2.685
Courant Number mean: 0.134252 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.00080295, Final residual = 6.20088e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023946, Final residual = 6.28347e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00393772, Final residual = 0.000319058, No Iterations 4
time step continuity errors : sum local = 8.64419e-08, global = -3.7601e-09, cumulative = 5.8035e-06
GAMG: Solving for p, Initial residual = 0.000748117, Final residual = 8.72182e-07, No Iterations 17
time step continuity errors : sum local = 2.36207e-10, global = 2.38329e-11, cumulative = 5.80352e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148453, Final residual = 9.46128e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164337, Final residual = 7.37094e-06, No Iterations 4
ExecutionTime = 27.04 s ClockTime = 27 s
Time = 2.6875
Courant Number mean: 0.134237 max: 0.616704
smoothSolver: Solving for Ux, Initial residual = 0.000803028, Final residual = 6.2386e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023941, Final residual = 6.31659e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00407878, Final residual = 0.000320321, No Iterations 4
time step continuity errors : sum local = 8.67238e-08, global = -3.7978e-09, cumulative = 5.79972e-06
GAMG: Solving for p, Initial residual = 0.00075505, Final residual = 9.76721e-07, No Iterations 17
time step continuity errors : sum local = 2.64319e-10, global = 2.92517e-11, cumulative = 5.79975e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148489, Final residual = 9.5006e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0016428, Final residual = 7.40347e-06, No Iterations 4
ExecutionTime = 27.06 s ClockTime = 27 s
Time = 2.69
Courant Number mean: 0.134221 max: 0.616703
smoothSolver: Solving for Ux, Initial residual = 0.000802971, Final residual = 6.27546e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239338, Final residual = 6.35133e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00385451, Final residual = 0.000318739, No Iterations 4
time step continuity errors : sum local = 8.62218e-08, global = -4.16184e-09, cumulative = 5.79559e-06
GAMG: Solving for p, Initial residual = 0.000739072, Final residual = 9.39602e-07, No Iterations 17
time step continuity errors : sum local = 2.541e-10, global = 2.67994e-11, cumulative = 5.79562e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148535, Final residual = 9.53713e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164227, Final residual = 7.43499e-06, No Iterations 4
ExecutionTime = 27.08 s ClockTime = 27 s
Time = 2.6925
Courant Number mean: 0.134203 max: 0.616703
smoothSolver: Solving for Ux, Initial residual = 0.000802898, Final residual = 6.31382e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239226, Final residual = 6.38627e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00391316, Final residual = 0.000314308, No Iterations 4
time step continuity errors : sum local = 8.49536e-08, global = -5.00483e-09, cumulative = 5.79061e-06
GAMG: Solving for p, Initial residual = 0.000741809, Final residual = 6.1557e-07, No Iterations 19
time step continuity errors : sum local = 1.66302e-10, global = 2.0732e-11, cumulative = 5.79063e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148572, Final residual = 9.57434e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164176, Final residual = 7.4662e-06, No Iterations 4
ExecutionTime = 27.11 s ClockTime = 27 s
Time = 2.695
Courant Number mean: 0.134183 max: 0.616703
smoothSolver: Solving for Ux, Initial residual = 0.000802912, Final residual = 6.3528e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00239053, Final residual = 6.42114e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00385005, Final residual = 0.000314274, No Iterations 4
time step continuity errors : sum local = 8.48699e-08, global = -5.08789e-09, cumulative = 5.78555e-06
GAMG: Solving for p, Initial residual = 0.000739409, Final residual = 6.48371e-07, No Iterations 19
time step continuity errors : sum local = 1.75024e-10, global = 2.27473e-11, cumulative = 5.78557e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148619, Final residual = 9.60908e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00164116, Final residual = 7.49893e-06, No Iterations 4
ExecutionTime = 27.14 s ClockTime = 27 s
Time = 2.6975
Courant Number mean: 0.134161 max: 0.616703
smoothSolver: Solving for Ux, Initial residual = 0.000802813, Final residual = 6.3917e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238859, Final residual = 6.4566e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00376398, Final residual = 0.000315785, No Iterations 4
time step continuity errors : sum local = 8.52106e-08, global = -5.15888e-09, cumulative = 5.78041e-06
GAMG: Solving for p, Initial residual = 0.000729869, Final residual = 6.55877e-07, No Iterations 19
time step continuity errors : sum local = 1.76913e-10, global = 2.29324e-11, cumulative = 5.78043e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148669, Final residual = 9.6496e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0016406, Final residual = 7.5323e-06, No Iterations 4
ExecutionTime = 27.17 s ClockTime = 27 s
Time = 2.7
Courant Number mean: 0.134138 max: 0.616703
smoothSolver: Solving for Ux, Initial residual = 0.000802754, Final residual = 6.43251e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023868, Final residual = 6.49349e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00379255, Final residual = 0.000315983, No Iterations 4
time step continuity errors : sum local = 8.52159e-08, global = -5.16939e-09, cumulative = 5.77526e-06
GAMG: Solving for p, Initial residual = 0.000727469, Final residual = 6.60035e-07, No Iterations 19
time step continuity errors : sum local = 1.77937e-10, global = 2.32233e-11, cumulative = 5.77529e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148751, Final residual = 9.69302e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00163999, Final residual = 7.56537e-06, No Iterations 4
ExecutionTime = 27.22 s ClockTime = 27 s
Time = 2.7025
Courant Number mean: 0.134114 max: 0.616703
smoothSolver: Solving for Ux, Initial residual = 0.000802831, Final residual = 6.47143e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238534, Final residual = 6.53035e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00393656, Final residual = 0.000323039, No Iterations 4
time step continuity errors : sum local = 8.70654e-08, global = -5.15598e-09, cumulative = 5.77013e-06
GAMG: Solving for p, Initial residual = 0.000741454, Final residual = 6.67674e-07, No Iterations 19
time step continuity errors : sum local = 1.79886e-10, global = 2.29692e-11, cumulative = 5.77015e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014883, Final residual = 9.73174e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00163931, Final residual = 7.59831e-06, No Iterations 4
ExecutionTime = 27.24 s ClockTime = 27 s
Time = 2.705
Courant Number mean: 0.134089 max: 0.616703
smoothSolver: Solving for Ux, Initial residual = 0.00080312, Final residual = 6.5116e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238378, Final residual = 6.56769e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.003799, Final residual = 0.000325366, No Iterations 4
time step continuity errors : sum local = 8.76188e-08, global = -5.23306e-09, cumulative = 5.76492e-06
GAMG: Solving for p, Initial residual = 0.000727656, Final residual = 7.09637e-07, No Iterations 19
time step continuity errors : sum local = 1.91004e-10, global = 2.5361e-11, cumulative = 5.76495e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148926, Final residual = 9.772e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00163853, Final residual = 7.63134e-06, No Iterations 4
ExecutionTime = 27.27 s ClockTime = 27 s
Time = 2.7075
Courant Number mean: 0.134072 max: 0.616703
smoothSolver: Solving for Ux, Initial residual = 0.0008034, Final residual = 6.55273e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238213, Final residual = 6.60554e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00383625, Final residual = 0.000327734, No Iterations 4
time step continuity errors : sum local = 8.81697e-08, global = -5.50741e-09, cumulative = 5.75944e-06
GAMG: Solving for p, Initial residual = 0.000734537, Final residual = 7.31029e-07, No Iterations 19
time step continuity errors : sum local = 1.96568e-10, global = 2.64896e-11, cumulative = 5.75946e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149016, Final residual = 9.81139e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00163759, Final residual = 7.66948e-06, No Iterations 4
ExecutionTime = 27.31 s ClockTime = 28 s
Time = 2.71
Courant Number mean: 0.134062 max: 0.616703
smoothSolver: Solving for Ux, Initial residual = 0.000803743, Final residual = 6.59388e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023808, Final residual = 6.64369e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00378883, Final residual = 0.000327434, No Iterations 4
time step continuity errors : sum local = 8.80124e-08, global = -5.71618e-09, cumulative = 5.75375e-06
GAMG: Solving for p, Initial residual = 0.000737468, Final residual = 6.69281e-07, No Iterations 22
time step continuity errors : sum local = 1.798e-10, global = -2.57585e-11, cumulative = 5.75372e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149092, Final residual = 9.85681e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00163668, Final residual = 7.70366e-06, No Iterations 4
ExecutionTime = 27.33 s ClockTime = 28 s
Time = 2.7125
Courant Number mean: 0.134052 max: 0.616702
smoothSolver: Solving for Ux, Initial residual = 0.000804045, Final residual = 6.63506e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238055, Final residual = 6.68274e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00392271, Final residual = 0.000332355, No Iterations 4
time step continuity errors : sum local = 8.92569e-08, global = -5.8709e-09, cumulative = 5.74785e-06
GAMG: Solving for p, Initial residual = 0.000752509, Final residual = 9.81672e-07, No Iterations 20
time step continuity errors : sum local = 2.6347e-10, global = -4.13448e-11, cumulative = 5.74781e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149172, Final residual = 9.90497e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0016359, Final residual = 7.73801e-06, No Iterations 4
ExecutionTime = 27.36 s ClockTime = 28 s
Time = 2.715
Courant Number mean: 0.134042 max: 0.616702
smoothSolver: Solving for Ux, Initial residual = 0.000804297, Final residual = 6.67763e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238031, Final residual = 6.72212e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00379539, Final residual = 0.000332477, No Iterations 4
time step continuity errors : sum local = 8.9206e-08, global = -5.86062e-09, cumulative = 5.74195e-06
GAMG: Solving for p, Initial residual = 0.000745564, Final residual = 6.79475e-07, No Iterations 22
time step continuity errors : sum local = 1.82201e-10, global = -2.60401e-11, cumulative = 5.74192e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149227, Final residual = 9.94824e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00163506, Final residual = 7.77278e-06, No Iterations 4
ExecutionTime = 27.39 s ClockTime = 28 s
Time = 2.7175
Courant Number mean: 0.134032 max: 0.616702
smoothSolver: Solving for Ux, Initial residual = 0.00080445, Final residual = 6.72005e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238022, Final residual = 6.76222e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0036883, Final residual = 0.000334322, No Iterations 4
time step continuity errors : sum local = 8.96525e-08, global = -5.77178e-09, cumulative = 5.73615e-06
GAMG: Solving for p, Initial residual = 0.000736394, Final residual = 6.83874e-07, No Iterations 22
time step continuity errors : sum local = 1.83291e-10, global = -2.61081e-11, cumulative = 5.73613e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149265, Final residual = 9.99136e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00163436, Final residual = 7.80782e-06, No Iterations 4
ExecutionTime = 27.41 s ClockTime = 28 s
Time = 2.72
Courant Number mean: 0.13402 max: 0.616702
smoothSolver: Solving for Ux, Initial residual = 0.000804539, Final residual = 6.76273e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238022, Final residual = 6.80294e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00365601, Final residual = 0.000336895, No Iterations 4
time step continuity errors : sum local = 9.02824e-08, global = -5.92985e-09, cumulative = 5.7302e-06
GAMG: Solving for p, Initial residual = 0.000742429, Final residual = 9.9474e-07, No Iterations 20
time step continuity errors : sum local = 2.66424e-10, global = -3.93986e-11, cumulative = 5.73016e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149294, Final residual = 2.50219e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00163346, Final residual = 7.84288e-06, No Iterations 4
ExecutionTime = 27.44 s ClockTime = 28 s
Time = 2.7225
Courant Number mean: 0.134007 max: 0.616702
smoothSolver: Solving for Ux, Initial residual = 0.000804518, Final residual = 6.80538e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00238005, Final residual = 6.843e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00368056, Final residual = 0.000340407, No Iterations 4
time step continuity errors : sum local = 9.11388e-08, global = -5.946e-09, cumulative = 5.72421e-06
GAMG: Solving for p, Initial residual = 0.000750131, Final residual = 6.83603e-07, No Iterations 22
time step continuity errors : sum local = 1.82907e-10, global = -2.55394e-11, cumulative = 5.72419e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149307, Final residual = 2.51355e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00163256, Final residual = 7.87697e-06, No Iterations 4
ExecutionTime = 27.47 s ClockTime = 28 s
Time = 2.725
Courant Number mean: 0.133993 max: 0.616702
smoothSolver: Solving for Ux, Initial residual = 0.000804434, Final residual = 6.84778e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237971, Final residual = 6.88262e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00384575, Final residual = 0.000343879, No Iterations 4
time step continuity errors : sum local = 9.19648e-08, global = -5.99867e-09, cumulative = 5.71819e-06
GAMG: Solving for p, Initial residual = 0.000761047, Final residual = 6.91764e-07, No Iterations 22
time step continuity errors : sum local = 1.8487e-10, global = -2.57532e-11, cumulative = 5.71816e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149321, Final residual = 2.52629e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00163171, Final residual = 7.9085e-06, No Iterations 4
ExecutionTime = 27.5 s ClockTime = 28 s
Time = 2.7275
Courant Number mean: 0.133977 max: 0.616702
smoothSolver: Solving for Ux, Initial residual = 0.000804331, Final residual = 6.8901e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237943, Final residual = 6.92293e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00400692, Final residual = 0.000348023, No Iterations 4
time step continuity errors : sum local = 9.29674e-08, global = -6.05725e-09, cumulative = 5.7121e-06
GAMG: Solving for p, Initial residual = 0.000777771, Final residual = 6.96168e-07, No Iterations 22
time step continuity errors : sum local = 1.85839e-10, global = -2.58439e-11, cumulative = 5.71208e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149364, Final residual = 2.53906e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00163093, Final residual = 7.94642e-06, No Iterations 4
ExecutionTime = 27.53 s ClockTime = 28 s
Time = 2.73
Courant Number mean: 0.133958 max: 0.616702
smoothSolver: Solving for Ux, Initial residual = 0.000804191, Final residual = 6.93399e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023787, Final residual = 6.96237e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00406488, Final residual = 0.000349766, No Iterations 4
time step continuity errors : sum local = 9.33783e-08, global = -6.10949e-09, cumulative = 5.70597e-06
GAMG: Solving for p, Initial residual = 0.000786068, Final residual = 7.16045e-07, No Iterations 22
time step continuity errors : sum local = 1.91038e-10, global = -2.66214e-11, cumulative = 5.70594e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149413, Final residual = 2.55223e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00163018, Final residual = 7.98696e-06, No Iterations 4
ExecutionTime = 27.55 s ClockTime = 28 s
Time = 2.7325
Courant Number mean: 0.133937 max: 0.616701
smoothSolver: Solving for Ux, Initial residual = 0.000804063, Final residual = 6.97812e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237745, Final residual = 7.00286e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00401307, Final residual = 0.000353849, No Iterations 4
time step continuity errors : sum local = 9.43695e-08, global = -6.20788e-09, cumulative = 5.69973e-06
GAMG: Solving for p, Initial residual = 0.000785902, Final residual = 7.21614e-07, No Iterations 22
time step continuity errors : sum local = 1.92308e-10, global = -2.667e-11, cumulative = 5.69971e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149476, Final residual = 2.56549e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00162939, Final residual = 8.01435e-06, No Iterations 4
ExecutionTime = 27.58 s ClockTime = 28 s
Time = 2.735
Courant Number mean: 0.133915 max: 0.616701
smoothSolver: Solving for Ux, Initial residual = 0.000803932, Final residual = 7.02316e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237558, Final residual = 7.04297e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00395622, Final residual = 0.000355038, No Iterations 4
time step continuity errors : sum local = 9.4607e-08, global = -6.26571e-09, cumulative = 5.69344e-06
GAMG: Solving for p, Initial residual = 0.000775006, Final residual = 7.38375e-07, No Iterations 22
time step continuity errors : sum local = 1.96642e-10, global = -2.73837e-11, cumulative = 5.69341e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149543, Final residual = 2.57944e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00162864, Final residual = 8.05273e-06, No Iterations 4
ExecutionTime = 27.61 s ClockTime = 28 s
Time = 2.7375
Courant Number mean: 0.13389 max: 0.616701
smoothSolver: Solving for Ux, Initial residual = 0.000804041, Final residual = 7.06867e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023738, Final residual = 7.08397e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00386288, Final residual = 0.000352985, No Iterations 4
time step continuity errors : sum local = 9.39834e-08, global = -6.32415e-09, cumulative = 5.68709e-06
GAMG: Solving for p, Initial residual = 0.000767072, Final residual = 7.36508e-07, No Iterations 22
time step continuity errors : sum local = 1.95964e-10, global = -2.7155e-11, cumulative = 5.68706e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149604, Final residual = 2.59317e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0016279, Final residual = 8.08685e-06, No Iterations 4
ExecutionTime = 27.65 s ClockTime = 28 s
Time = 2.74
Courant Number mean: 0.133864 max: 0.616701
smoothSolver: Solving for Ux, Initial residual = 0.000804186, Final residual = 7.11547e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00237182, Final residual = 7.12559e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00378296, Final residual = 0.000352988, No Iterations 4
time step continuity errors : sum local = 9.38959e-08, global = -6.41454e-09, cumulative = 5.68065e-06
GAMG: Solving for p, Initial residual = 0.000766303, Final residual = 7.45023e-07, No Iterations 22
time step continuity errors : sum local = 1.98043e-10, global = -2.75202e-11, cumulative = 5.68062e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149647, Final residual = 2.60655e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00162702, Final residual = 8.12267e-06, No Iterations 4
ExecutionTime = 27.67 s ClockTime = 28 s
Time = 2.7425
Courant Number mean: 0.133836 max: 0.616701
smoothSolver: Solving for Ux, Initial residual = 0.000804304, Final residual = 7.16086e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023693, Final residual = 7.16754e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00381404, Final residual = 0.000353517, No Iterations 4
time step continuity errors : sum local = 9.39772e-08, global = -6.42258e-09, cumulative = 5.6742e-06
GAMG: Solving for p, Initial residual = 0.000771668, Final residual = 7.75891e-07, No Iterations 22
time step continuity errors : sum local = 2.0612e-10, global = -2.89297e-11, cumulative = 5.67417e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149684, Final residual = 2.61958e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00162607, Final residual = 8.16033e-06, No Iterations 4
ExecutionTime = 27.7 s ClockTime = 28 s
Time = 2.745
Courant Number mean: 0.133806 max: 0.616701
smoothSolver: Solving for Ux, Initial residual = 0.000804585, Final residual = 7.20745e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00236687, Final residual = 7.20875e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00391267, Final residual = 0.00035555, No Iterations 4
time step continuity errors : sum local = 9.44241e-08, global = -6.64778e-09, cumulative = 5.66752e-06
GAMG: Solving for p, Initial residual = 0.000788307, Final residual = 7.57579e-07, No Iterations 22
time step continuity errors : sum local = 2.01045e-10, global = -2.7623e-11, cumulative = 5.66749e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149709, Final residual = 2.63499e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00162514, Final residual = 8.19617e-06, No Iterations 4
ExecutionTime = 27.73 s ClockTime = 28 s
Time = 2.7475
Courant Number mean: 0.133777 max: 0.616701
smoothSolver: Solving for Ux, Initial residual = 0.000804896, Final residual = 7.25425e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00236435, Final residual = 7.24896e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00411484, Final residual = 0.00035698, No Iterations 4
time step continuity errors : sum local = 9.47034e-08, global = -6.95933e-09, cumulative = 5.66053e-06
GAMG: Solving for p, Initial residual = 0.000799322, Final residual = 8.64979e-07, No Iterations 22
time step continuity errors : sum local = 2.29282e-10, global = -3.38971e-11, cumulative = 5.6605e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149737, Final residual = 2.64779e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00162403, Final residual = 8.23363e-06, No Iterations 4
ExecutionTime = 27.75 s ClockTime = 28 s
Time = 2.75
Courant Number mean: 0.133749 max: 0.616701
smoothSolver: Solving for Ux, Initial residual = 0.000805019, Final residual = 7.29813e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00236289, Final residual = 7.29558e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00403748, Final residual = 0.000356218, No Iterations 4
time step continuity errors : sum local = 9.43957e-08, global = -6.92399e-09, cumulative = 5.65358e-06
GAMG: Solving for p, Initial residual = 0.000809639, Final residual = 7.81274e-07, No Iterations 22
time step continuity errors : sum local = 2.06855e-10, global = -2.92095e-11, cumulative = 5.65355e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149759, Final residual = 2.6617e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00162298, Final residual = 8.26854e-06, No Iterations 4
ExecutionTime = 27.78 s ClockTime = 28 s
Time = 2.7525
Courant Number mean: 0.133729 max: 0.616701
smoothSolver: Solving for Ux, Initial residual = 0.000805177, Final residual = 7.34636e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00236145, Final residual = 7.33843e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00398151, Final residual = 0.00035641, No Iterations 4
time step continuity errors : sum local = 9.43442e-08, global = -7.03586e-09, cumulative = 5.64651e-06
GAMG: Solving for p, Initial residual = 0.000809244, Final residual = 8.16571e-07, No Iterations 22
time step continuity errors : sum local = 2.1601e-10, global = -3.07481e-11, cumulative = 5.64648e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149757, Final residual = 2.67593e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00162196, Final residual = 8.30852e-06, No Iterations 4
ExecutionTime = 27.8 s ClockTime = 28 s
Time = 2.755
Courant Number mean: 0.133712 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.00080528, Final residual = 7.39432e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00236052, Final residual = 7.3822e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00387666, Final residual = 0.000356585, No Iterations 4
time step continuity errors : sum local = 9.43088e-08, global = -7.19776e-09, cumulative = 5.63928e-06
GAMG: Solving for p, Initial residual = 0.000796304, Final residual = 8.11752e-07, No Iterations 22
time step continuity errors : sum local = 2.14544e-10, global = -3.09422e-11, cumulative = 5.63925e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149755, Final residual = 2.69054e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00162096, Final residual = 8.3478e-06, No Iterations 4
ExecutionTime = 27.83 s ClockTime = 28 s
Time = 2.7575
Courant Number mean: 0.133694 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.000805317, Final residual = 7.44288e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235925, Final residual = 7.42623e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00386168, Final residual = 0.000362744, No Iterations 4
time step continuity errors : sum local = 9.58609e-08, global = -7.63521e-09, cumulative = 5.63162e-06
GAMG: Solving for p, Initial residual = 0.000805207, Final residual = 7.42384e-07, No Iterations 22
time step continuity errors : sum local = 1.9608e-10, global = -2.5879e-11, cumulative = 5.63159e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149757, Final residual = 2.70526e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00161985, Final residual = 8.37937e-06, No Iterations 4
ExecutionTime = 27.85 s ClockTime = 28 s
Time = 2.76
Courant Number mean: 0.133677 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.000805257, Final residual = 7.49186e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235823, Final residual = 7.4704e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00381794, Final residual = 0.00036287, No Iterations 4
time step continuity errors : sum local = 9.58556e-08, global = -7.71772e-09, cumulative = 5.62387e-06
GAMG: Solving for p, Initial residual = 0.000794064, Final residual = 7.58442e-07, No Iterations 22
time step continuity errors : sum local = 2.00241e-10, global = -2.66743e-11, cumulative = 5.62385e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149792, Final residual = 2.72127e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00161873, Final residual = 8.41748e-06, No Iterations 4
ExecutionTime = 27.88 s ClockTime = 28 s
Time = 2.7625
Courant Number mean: 0.133658 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.000805117, Final residual = 7.54059e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235723, Final residual = 7.51589e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00391813, Final residual = 0.000360484, No Iterations 4
time step continuity errors : sum local = 9.51576e-08, global = -7.81365e-09, cumulative = 5.61603e-06
GAMG: Solving for p, Initial residual = 0.000801924, Final residual = 7.59427e-07, No Iterations 22
time step continuity errors : sum local = 2.0032e-10, global = -2.70052e-11, cumulative = 5.61601e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149824, Final residual = 2.7367e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00161777, Final residual = 8.45505e-06, No Iterations 4
ExecutionTime = 27.91 s ClockTime = 28 s
Time = 2.765
Courant Number mean: 0.133638 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.000804937, Final residual = 7.58936e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023561, Final residual = 7.56137e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00384183, Final residual = 0.000361761, No Iterations 4
time step continuity errors : sum local = 9.5367e-08, global = -7.91604e-09, cumulative = 5.60809e-06
GAMG: Solving for p, Initial residual = 0.0007937, Final residual = 7.61743e-07, No Iterations 22
time step continuity errors : sum local = 2.0062e-10, global = -2.66685e-11, cumulative = 5.60806e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149857, Final residual = 2.75188e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00161675, Final residual = 8.49728e-06, No Iterations 4
ExecutionTime = 27.94 s ClockTime = 28 s
Time = 2.7675
Courant Number mean: 0.133616 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.000804682, Final residual = 7.63854e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235474, Final residual = 7.60724e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0037967, Final residual = 0.000360436, No Iterations 4
time step continuity errors : sum local = 9.48769e-08, global = -7.95227e-09, cumulative = 5.60011e-06
GAMG: Solving for p, Initial residual = 0.000795999, Final residual = 7.65619e-07, No Iterations 22
time step continuity errors : sum local = 2.01328e-10, global = -2.69988e-11, cumulative = 5.60008e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149897, Final residual = 2.76693e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00161568, Final residual = 8.53619e-06, No Iterations 4
ExecutionTime = 27.96 s ClockTime = 28 s
Time = 2.77
Courant Number mean: 0.133593 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.000804466, Final residual = 7.69008e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235317, Final residual = 7.65409e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0040135, Final residual = 0.000362824, No Iterations 4
time step continuity errors : sum local = 9.53943e-08, global = -8.06537e-09, cumulative = 5.59202e-06
GAMG: Solving for p, Initial residual = 0.000828678, Final residual = 7.72261e-07, No Iterations 22
time step continuity errors : sum local = 2.02861e-10, global = -2.70166e-11, cumulative = 5.59199e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149946, Final residual = 2.78137e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00161471, Final residual = 8.57553e-06, No Iterations 4
ExecutionTime = 27.99 s ClockTime = 28 s
Time = 2.7725
Courant Number mean: 0.133568 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.000804165, Final residual = 7.74257e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00235111, Final residual = 7.7004e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00376165, Final residual = 0.000363219, No Iterations 4
time step continuity errors : sum local = 9.53806e-08, global = -8.13971e-09, cumulative = 5.58385e-06
GAMG: Solving for p, Initial residual = 0.000803189, Final residual = 7.81652e-07, No Iterations 22
time step continuity errors : sum local = 2.05092e-10, global = -2.77507e-11, cumulative = 5.58382e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014997, Final residual = 2.79652e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00161378, Final residual = 8.61217e-06, No Iterations 4
ExecutionTime = 28.02 s ClockTime = 28 s
Time = 2.775
Courant Number mean: 0.133541 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.000803755, Final residual = 7.79437e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023491, Final residual = 7.75003e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00388926, Final residual = 0.000363207, No Iterations 4
time step continuity errors : sum local = 9.52642e-08, global = -8.22863e-09, cumulative = 5.5756e-06
GAMG: Solving for p, Initial residual = 0.000812291, Final residual = 7.83678e-07, No Iterations 22
time step continuity errors : sum local = 2.05377e-10, global = -2.72341e-11, cumulative = 5.57557e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149987, Final residual = 2.81116e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00161274, Final residual = 8.65046e-06, No Iterations 4
ExecutionTime = 28.04 s ClockTime = 28 s
Time = 2.7775
Courant Number mean: 0.133512 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.000803496, Final residual = 7.84821e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234669, Final residual = 7.79864e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00376978, Final residual = 0.000365317, No Iterations 4
time step continuity errors : sum local = 9.57093e-08, global = -8.28608e-09, cumulative = 5.56728e-06
GAMG: Solving for p, Initial residual = 0.000806301, Final residual = 8.00398e-07, No Iterations 22
time step continuity errors : sum local = 2.09536e-10, global = -2.77423e-11, cumulative = 5.56725e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149996, Final residual = 2.82656e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00161162, Final residual = 8.69076e-06, No Iterations 4
ExecutionTime = 28.07 s ClockTime = 28 s
Time = 2.78
Courant Number mean: 0.13348 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.000803367, Final residual = 7.90221e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234419, Final residual = 7.84888e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00392259, Final residual = 0.000367017, No Iterations 4
time step continuity errors : sum local = 9.60553e-08, global = -8.35346e-09, cumulative = 5.5589e-06
GAMG: Solving for p, Initial residual = 0.000826521, Final residual = 8.06635e-07, No Iterations 22
time step continuity errors : sum local = 2.10952e-10, global = -2.81483e-11, cumulative = 5.55887e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149995, Final residual = 2.84244e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00161054, Final residual = 8.73149e-06, No Iterations 4
ExecutionTime = 28.1 s ClockTime = 28 s
Time = 2.7825
Courant Number mean: 0.133447 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 0.000803298, Final residual = 7.95645e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00234173, Final residual = 7.89904e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00389946, Final residual = 0.000365928, No Iterations 4
time step continuity errors : sum local = 9.56911e-08, global = -8.37964e-09, cumulative = 5.55049e-06
GAMG: Solving for p, Initial residual = 0.000831993, Final residual = 8.0954e-07, No Iterations 22
time step continuity errors : sum local = 2.1156e-10, global = -2.813e-11, cumulative = 5.55046e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149988, Final residual = 2.85697e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00160933, Final residual = 8.77631e-06, No Iterations 4
ExecutionTime = 28.13 s ClockTime = 28 s
Time = 2.785
Courant Number mean: 0.133413 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000803195, Final residual = 8.01057e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00233903, Final residual = 7.95037e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00394121, Final residual = 0.000367081, No Iterations 4
time step continuity errors : sum local = 9.59471e-08, global = -8.431e-09, cumulative = 5.54203e-06
GAMG: Solving for p, Initial residual = 0.000843689, Final residual = 8.07509e-07, No Iterations 22
time step continuity errors : sum local = 2.10923e-10, global = -2.76851e-11, cumulative = 5.54201e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149987, Final residual = 2.87365e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00160804, Final residual = 8.81981e-06, No Iterations 4
ExecutionTime = 28.16 s ClockTime = 28 s
Time = 2.7875
Courant Number mean: 0.133377 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000803194, Final residual = 8.06527e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023375, Final residual = 8.00116e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00406473, Final residual = 0.000367297, No Iterations 4
time step continuity errors : sum local = 9.59032e-08, global = -8.50402e-09, cumulative = 5.5335e-06
GAMG: Solving for p, Initial residual = 0.000864301, Final residual = 8.04209e-07, No Iterations 22
time step continuity errors : sum local = 2.09782e-10, global = -2.73048e-11, cumulative = 5.53347e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0015, Final residual = 2.88811e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00160677, Final residual = 8.86291e-06, No Iterations 4
ExecutionTime = 28.2 s ClockTime = 28 s
Time = 2.79
Courant Number mean: 0.13334 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000803213, Final residual = 8.12012e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00233622, Final residual = 8.05236e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00393654, Final residual = 0.000368333, No Iterations 4
time step continuity errors : sum local = 9.60584e-08, global = -8.56225e-09, cumulative = 5.52491e-06
GAMG: Solving for p, Initial residual = 0.000855577, Final residual = 8.05932e-07, No Iterations 22
time step continuity errors : sum local = 2.10008e-10, global = -2.73372e-11, cumulative = 5.52489e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00150021, Final residual = 2.90619e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00160549, Final residual = 8.90302e-06, No Iterations 4
ExecutionTime = 28.23 s ClockTime = 28 s
Time = 2.7925
Courant Number mean: 0.133303 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000803146, Final residual = 8.17545e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00233455, Final residual = 8.10378e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00398957, Final residual = 0.000368819, No Iterations 4
time step continuity errors : sum local = 9.60732e-08, global = -8.61817e-09, cumulative = 5.51627e-06
GAMG: Solving for p, Initial residual = 0.000857475, Final residual = 8.12305e-07, No Iterations 22
time step continuity errors : sum local = 2.11417e-10, global = -2.7518e-11, cumulative = 5.51624e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00150057, Final residual = 2.92278e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00160433, Final residual = 8.95027e-06, No Iterations 4
ExecutionTime = 28.26 s ClockTime = 28 s
Time = 2.795
Courant Number mean: 0.133273 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000803091, Final residual = 8.23095e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00233294, Final residual = 8.15552e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00404905, Final residual = 0.000370034, No Iterations 4
time step continuity errors : sum local = 9.62759e-08, global = -8.66732e-09, cumulative = 5.50757e-06
GAMG: Solving for p, Initial residual = 0.00085799, Final residual = 8.18969e-07, No Iterations 22
time step continuity errors : sum local = 2.12895e-10, global = -2.80175e-11, cumulative = 5.50754e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00150091, Final residual = 2.94003e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00160313, Final residual = 8.99392e-06, No Iterations 4
ExecutionTime = 28.28 s ClockTime = 28 s
Time = 2.7975
Courant Number mean: 0.133247 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000802953, Final residual = 8.28579e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00233118, Final residual = 8.20786e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00409158, Final residual = 0.000374701, No Iterations 4
time step continuity errors : sum local = 9.73986e-08, global = -8.76415e-09, cumulative = 5.49878e-06
GAMG: Solving for p, Initial residual = 0.000868827, Final residual = 8.34205e-07, No Iterations 22
time step continuity errors : sum local = 2.16652e-10, global = -2.81216e-11, cumulative = 5.49875e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00150099, Final residual = 2.95529e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00160193, Final residual = 9.0367e-06, No Iterations 4
ExecutionTime = 28.31 s ClockTime = 29 s
Time = 2.8
Courant Number mean: 0.133221 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000802732, Final residual = 8.34319e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00232928, Final residual = 8.2604e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00395247, Final residual = 0.000377031, No Iterations 4
time step continuity errors : sum local = 9.78948e-08, global = -8.8295e-09, cumulative = 5.48992e-06
GAMG: Solving for p, Initial residual = 0.0008671, Final residual = 8.35566e-07, No Iterations 22
time step continuity errors : sum local = 2.16772e-10, global = -2.77521e-11, cumulative = 5.48989e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0015008, Final residual = 2.97376e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00160054, Final residual = 9.07698e-06, No Iterations 4
ExecutionTime = 28.36 s ClockTime = 29 s
Time = 2.8025
Courant Number mean: 0.133194 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000802416, Final residual = 8.40013e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00232737, Final residual = 8.31431e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00387736, Final residual = 0.000377449, No Iterations 4
time step continuity errors : sum local = 9.78917e-08, global = -8.83665e-09, cumulative = 5.48106e-06
GAMG: Solving for p, Initial residual = 0.000858449, Final residual = 8.36965e-07, No Iterations 22
time step continuity errors : sum local = 2.16882e-10, global = -2.75099e-11, cumulative = 5.48103e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00150062, Final residual = 2.99019e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00159921, Final residual = 9.12125e-06, No Iterations 4
ExecutionTime = 28.39 s ClockTime = 29 s
Time = 2.805
Courant Number mean: 0.133167 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000802103, Final residual = 8.45839e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023254, Final residual = 8.3688e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00396885, Final residual = 0.000380667, No Iterations 4
time step continuity errors : sum local = 9.862e-08, global = -8.92154e-09, cumulative = 5.47211e-06
GAMG: Solving for p, Initial residual = 0.000858807, Final residual = 8.37764e-07, No Iterations 22
time step continuity errors : sum local = 2.16833e-10, global = -2.68973e-11, cumulative = 5.47208e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00150041, Final residual = 3.00571e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00159789, Final residual = 9.1662e-06, No Iterations 4
ExecutionTime = 28.42 s ClockTime = 29 s
Time = 2.8075
Courant Number mean: 0.133139 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000801686, Final residual = 8.51523e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00232311, Final residual = 8.42421e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00398796, Final residual = 0.000381758, No Iterations 4
time step continuity errors : sum local = 9.87557e-08, global = -8.94511e-09, cumulative = 5.46314e-06
GAMG: Solving for p, Initial residual = 0.00086259, Final residual = 8.58945e-07, No Iterations 22
time step continuity errors : sum local = 2.21952e-10, global = -2.78168e-11, cumulative = 5.46311e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00150008, Final residual = 3.02256e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00159663, Final residual = 9.21489e-06, No Iterations 4
ExecutionTime = 28.45 s ClockTime = 29 s
Time = 2.81
Courant Number mean: 0.133109 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000801399, Final residual = 8.57605e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00232052, Final residual = 8.4793e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00406622, Final residual = 0.000385493, No Iterations 4
time step continuity errors : sum local = 9.95838e-08, global = -8.97861e-09, cumulative = 5.45413e-06
GAMG: Solving for p, Initial residual = 0.000872942, Final residual = 8.76571e-07, No Iterations 22
time step continuity errors : sum local = 2.26201e-10, global = -2.81825e-11, cumulative = 5.4541e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149954, Final residual = 3.04062e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00159538, Final residual = 9.26143e-06, No Iterations 4
ExecutionTime = 28.47 s ClockTime = 29 s
Time = 2.8125
Courant Number mean: 0.133078 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000801242, Final residual = 8.63756e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231795, Final residual = 8.53448e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00392325, Final residual = 0.000385946, No Iterations 4
time step continuity errors : sum local = 9.95499e-08, global = -9.04072e-09, cumulative = 5.44506e-06
GAMG: Solving for p, Initial residual = 0.000859363, Final residual = 8.78084e-07, No Iterations 22
time step continuity errors : sum local = 2.26257e-10, global = -2.80857e-11, cumulative = 5.44503e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149897, Final residual = 3.05766e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00159422, Final residual = 9.30786e-06, No Iterations 4
ExecutionTime = 28.5 s ClockTime = 29 s
Time = 2.815
Courant Number mean: 0.133045 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000801109, Final residual = 8.70011e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231495, Final residual = 8.59059e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00382918, Final residual = 0.000241907, No Iterations 5
time step continuity errors : sum local = 6.23043e-08, global = 6.0798e-09, cumulative = 5.45111e-06
GAMG: Solving for p, Initial residual = 0.000821229, Final residual = 6.91964e-07, No Iterations 23
time step continuity errors : sum local = 1.78059e-10, global = -2.58433e-11, cumulative = 5.45109e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149852, Final residual = 3.07579e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00159302, Final residual = 9.35524e-06, No Iterations 4
ExecutionTime = 28.53 s ClockTime = 29 s
Time = 2.8175
Courant Number mean: 0.133011 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000800864, Final residual = 8.76313e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00231189, Final residual = 8.64945e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00388027, Final residual = 0.000252451, No Iterations 5
time step continuity errors : sum local = 6.49334e-08, global = 6.36598e-09, cumulative = 5.45745e-06
GAMG: Solving for p, Initial residual = 0.000838268, Final residual = 6.83429e-07, No Iterations 23
time step continuity errors : sum local = 1.75628e-10, global = -2.54161e-11, cumulative = 5.45743e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149828, Final residual = 3.09551e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00159166, Final residual = 9.40311e-06, No Iterations 4
ExecutionTime = 28.56 s ClockTime = 29 s
Time = 2.82
Courant Number mean: 0.132975 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000800684, Final residual = 8.82718e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0023083, Final residual = 8.70612e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00379479, Final residual = 0.000252315, No Iterations 5
time step continuity errors : sum local = 6.48221e-08, global = 6.3915e-09, cumulative = 5.46382e-06
GAMG: Solving for p, Initial residual = 0.00084222, Final residual = 6.8979e-07, No Iterations 23
time step continuity errors : sum local = 1.77068e-10, global = -2.55791e-11, cumulative = 5.46379e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149812, Final residual = 3.11473e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00159033, Final residual = 9.45569e-06, No Iterations 4
ExecutionTime = 28.59 s ClockTime = 29 s
Time = 2.8225
Courant Number mean: 0.132937 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000800474, Final residual = 8.89073e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00230514, Final residual = 8.76499e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00374125, Final residual = 0.00025044, No Iterations 5
time step continuity errors : sum local = 6.4303e-08, global = 6.32089e-09, cumulative = 5.47011e-06
GAMG: Solving for p, Initial residual = 0.000829217, Final residual = 6.94029e-07, No Iterations 23
time step continuity errors : sum local = 1.78057e-10, global = -2.53163e-11, cumulative = 5.47009e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149819, Final residual = 3.13273e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00158896, Final residual = 9.50488e-06, No Iterations 4
ExecutionTime = 28.61 s ClockTime = 29 s
Time = 2.825
Courant Number mean: 0.132897 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000800221, Final residual = 8.95423e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00230212, Final residual = 8.8233e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00393443, Final residual = 0.000254319, No Iterations 5
time step continuity errors : sum local = 6.52138e-08, global = 6.39607e-09, cumulative = 5.47649e-06
GAMG: Solving for p, Initial residual = 0.000850598, Final residual = 7.13589e-07, No Iterations 23
time step continuity errors : sum local = 1.82783e-10, global = -2.59316e-11, cumulative = 5.47646e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149814, Final residual = 3.15139e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00158752, Final residual = 9.55564e-06, No Iterations 4
ExecutionTime = 28.64 s ClockTime = 29 s
Time = 2.8275
Courant Number mean: 0.132856 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000800074, Final residual = 9.01768e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00229938, Final residual = 8.88267e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00397678, Final residual = 0.000256196, No Iterations 5
time step continuity errors : sum local = 6.56056e-08, global = 6.50456e-09, cumulative = 5.48296e-06
GAMG: Solving for p, Initial residual = 0.000876577, Final residual = 7.12872e-07, No Iterations 23
time step continuity errors : sum local = 1.82381e-10, global = -2.59016e-11, cumulative = 5.48294e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149816, Final residual = 3.17057e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00158614, Final residual = 9.60609e-06, No Iterations 4
ExecutionTime = 28.67 s ClockTime = 29 s
Time = 2.83
Courant Number mean: 0.132813 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000799845, Final residual = 9.08182e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00229679, Final residual = 8.94232e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00406161, Final residual = 0.00025754, No Iterations 5
time step continuity errors : sum local = 6.58449e-08, global = 6.5681e-09, cumulative = 5.48951e-06
GAMG: Solving for p, Initial residual = 0.000912843, Final residual = 7.23865e-07, No Iterations 23
time step continuity errors : sum local = 1.84851e-10, global = -2.60688e-11, cumulative = 5.48948e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149804, Final residual = 3.18992e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00158487, Final residual = 9.65566e-06, No Iterations 4
ExecutionTime = 28.7 s ClockTime = 29 s
Time = 2.8325
Courant Number mean: 0.132769 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000799537, Final residual = 9.14719e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00229394, Final residual = 9.00172e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00415328, Final residual = 0.000402699, No Iterations 4
time step continuity errors : sum local = 1.02761e-07, global = -9.54129e-09, cumulative = 5.47994e-06
GAMG: Solving for p, Initial residual = 0.000934395, Final residual = 9.83523e-07, No Iterations 22
time step continuity errors : sum local = 2.50678e-10, global = -3.122e-11, cumulative = 5.47991e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149772, Final residual = 3.20688e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00158346, Final residual = 9.71141e-06, No Iterations 4
ExecutionTime = 28.72 s ClockTime = 29 s
Time = 2.835
Courant Number mean: 0.132725 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000799084, Final residual = 9.20976e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00229112, Final residual = 9.06526e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00414223, Final residual = 0.000398147, No Iterations 4
time step continuity errors : sum local = 1.0147e-07, global = -9.56852e-09, cumulative = 5.47034e-06
GAMG: Solving for p, Initial residual = 0.000938874, Final residual = 9.48779e-07, No Iterations 22
time step continuity errors : sum local = 2.41568e-10, global = -2.92443e-11, cumulative = 5.47031e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149721, Final residual = 3.22738e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00158182, Final residual = 9.7647e-06, No Iterations 4
ExecutionTime = 28.74 s ClockTime = 29 s
Time = 2.8375
Courant Number mean: 0.132683 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000798611, Final residual = 9.27683e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00228847, Final residual = 9.12622e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0038248, Final residual = 0.000248468, No Iterations 5
time step continuity errors : sum local = 6.32425e-08, global = 6.38476e-09, cumulative = 5.47669e-06
GAMG: Solving for p, Initial residual = 0.000880318, Final residual = 7.50349e-07, No Iterations 23
time step continuity errors : sum local = 1.90821e-10, global = -2.66496e-11, cumulative = 5.47667e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149663, Final residual = 3.24706e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00158018, Final residual = 9.81501e-06, No Iterations 4
ExecutionTime = 28.77 s ClockTime = 29 s
Time = 2.84
Courant Number mean: 0.132646 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.00079802, Final residual = 9.34257e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.0022856, Final residual = 9.1916e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00393693, Final residual = 0.000259704, No Iterations 5
time step continuity errors : sum local = 6.60305e-08, global = 6.6954e-09, cumulative = 5.48336e-06
GAMG: Solving for p, Initial residual = 0.000898073, Final residual = 7.44223e-07, No Iterations 23
time step continuity errors : sum local = 1.89057e-10, global = -2.61437e-11, cumulative = 5.48334e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149571, Final residual = 3.26776e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0015785, Final residual = 9.86686e-06, No Iterations 4
ExecutionTime = 28.81 s ClockTime = 29 s
Time = 2.8425
Courant Number mean: 0.132608 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000797389, Final residual = 9.41066e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00228218, Final residual = 9.25481e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00406526, Final residual = 0.000261259, No Iterations 5
time step continuity errors : sum local = 6.63655e-08, global = 6.74433e-09, cumulative = 5.49008e-06
GAMG: Solving for p, Initial residual = 0.000892532, Final residual = 7.45646e-07, No Iterations 23
time step continuity errors : sum local = 1.89233e-10, global = -2.60449e-11, cumulative = 5.49006e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149479, Final residual = 3.29023e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00157677, Final residual = 9.9212e-06, No Iterations 4
ExecutionTime = 28.84 s ClockTime = 29 s
Time = 2.845
Courant Number mean: 0.132571 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000796687, Final residual = 9.48042e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00227868, Final residual = 9.31845e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00391424, Final residual = 0.00026156, No Iterations 5
time step continuity errors : sum local = 6.63542e-08, global = 6.80135e-09, cumulative = 5.49686e-06
GAMG: Solving for p, Initial residual = 0.000888513, Final residual = 7.49503e-07, No Iterations 23
time step continuity errors : sum local = 1.89961e-10, global = -2.63271e-11, cumulative = 5.49683e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149415, Final residual = 3.31059e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00157503, Final residual = 9.97839e-06, No Iterations 4
ExecutionTime = 28.87 s ClockTime = 29 s
Time = 2.8475
Courant Number mean: 0.132532 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000795923, Final residual = 9.55071e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00227489, Final residual = 9.38314e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00404452, Final residual = 0.000263958, No Iterations 5
time step continuity errors : sum local = 6.68788e-08, global = 6.87898e-09, cumulative = 5.50371e-06
GAMG: Solving for p, Initial residual = 0.000914978, Final residual = 7.69698e-07, No Iterations 23
time step continuity errors : sum local = 1.94781e-10, global = -2.70995e-11, cumulative = 5.50368e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149363, Final residual = 3.33249e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00157356, Final residual = 3.32217e-06, No Iterations 5
ExecutionTime = 28.89 s ClockTime = 29 s
Time = 2.85
Courant Number mean: 0.132493 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000795177, Final residual = 9.62148e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00227093, Final residual = 9.4499e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00388356, Final residual = 0.000266749, No Iterations 5
time step continuity errors : sum local = 6.74722e-08, global = 6.98271e-09, cumulative = 5.51067e-06
GAMG: Solving for p, Initial residual = 0.000906844, Final residual = 7.72696e-07, No Iterations 23
time step continuity errors : sum local = 1.95229e-10, global = -2.70484e-11, cumulative = 5.51064e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149326, Final residual = 3.35515e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00157215, Final residual = 3.34391e-06, No Iterations 5
ExecutionTime = 28.92 s ClockTime = 29 s
Time = 2.8525
Courant Number mean: 0.132451 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000794626, Final residual = 9.69356e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00226676, Final residual = 9.51743e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00385196, Final residual = 0.000269256, No Iterations 5
time step continuity errors : sum local = 6.80078e-08, global = 7.0673e-09, cumulative = 5.51771e-06
GAMG: Solving for p, Initial residual = 0.000900513, Final residual = 7.72517e-07, No Iterations 23
time step continuity errors : sum local = 1.94934e-10, global = -2.69952e-11, cumulative = 5.51768e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149292, Final residual = 3.37762e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00157057, Final residual = 3.36624e-06, No Iterations 5
ExecutionTime = 28.95 s ClockTime = 29 s
Time = 2.855
Courant Number mean: 0.132409 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000794233, Final residual = 9.76477e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00226235, Final residual = 9.58588e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00394955, Final residual = 0.000268465, No Iterations 5
time step continuity errors : sum local = 6.772e-08, global = 7.04644e-09, cumulative = 5.52473e-06
GAMG: Solving for p, Initial residual = 0.000901156, Final residual = 8.16017e-07, No Iterations 23
time step continuity errors : sum local = 2.05661e-10, global = -2.89219e-11, cumulative = 5.5247e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149243, Final residual = 3.40141e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00156892, Final residual = 3.38835e-06, No Iterations 5
ExecutionTime = 29.03 s ClockTime = 29 s
Time = 2.8575
Courant Number mean: 0.132365 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000793794, Final residual = 9.83796e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00225805, Final residual = 9.65495e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00402257, Final residual = 0.000268676, No Iterations 5
time step continuity errors : sum local = 6.76985e-08, global = 7.06628e-09, cumulative = 5.53176e-06
GAMG: Solving for p, Initial residual = 0.000910097, Final residual = 8.29692e-07, No Iterations 23
time step continuity errors : sum local = 2.08891e-10, global = -2.9211e-11, cumulative = 5.53173e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149187, Final residual = 3.42665e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0015673, Final residual = 3.41281e-06, No Iterations 5
ExecutionTime = 29.06 s ClockTime = 29 s
Time = 2.86
Courant Number mean: 0.13232 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000793294, Final residual = 9.91229e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00225437, Final residual = 9.72372e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00381354, Final residual = 0.000272958, No Iterations 5
time step continuity errors : sum local = 6.87183e-08, global = 7.22423e-09, cumulative = 5.53896e-06
GAMG: Solving for p, Initial residual = 0.000902916, Final residual = 8.35184e-07, No Iterations 23
time step continuity errors : sum local = 2.10071e-10, global = -2.92203e-11, cumulative = 5.53893e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00149124, Final residual = 3.45017e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00156565, Final residual = 3.43525e-06, No Iterations 5
ExecutionTime = 29.09 s ClockTime = 29 s
Time = 2.8625
Courant Number mean: 0.132273 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000792666, Final residual = 9.98638e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00225151, Final residual = 9.79391e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0037663, Final residual = 0.000273572, No Iterations 5
time step continuity errors : sum local = 6.88184e-08, global = 7.25312e-09, cumulative = 5.54618e-06
GAMG: Solving for p, Initial residual = 0.000895362, Final residual = 8.43293e-07, No Iterations 23
time step continuity errors : sum local = 2.11921e-10, global = -2.94479e-11, cumulative = 5.54615e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014903, Final residual = 3.47366e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00156403, Final residual = 3.45769e-06, No Iterations 5
ExecutionTime = 29.12 s ClockTime = 29 s
Time = 2.865
Courant Number mean: 0.132224 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000792, Final residual = 3.09719e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0022489, Final residual = 9.86608e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00385161, Final residual = 0.000261461, No Iterations 5
time step continuity errors : sum local = 6.56553e-08, global = 6.57727e-09, cumulative = 5.55273e-06
GAMG: Solving for p, Initial residual = 0.000869309, Final residual = 8.41744e-07, No Iterations 19
time step continuity errors : sum local = 2.11153e-10, global = -2.03032e-11, cumulative = 5.55271e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148933, Final residual = 3.4996e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00156253, Final residual = 3.48184e-06, No Iterations 5
ExecutionTime = 29.15 s ClockTime = 29 s
Time = 2.8675
Courant Number mean: 0.132174 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000790925, Final residual = 3.11879e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0022468, Final residual = 9.94577e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00382813, Final residual = 0.000261157, No Iterations 5
time step continuity errors : sum local = 6.54763e-08, global = 6.4453e-09, cumulative = 5.55915e-06
GAMG: Solving for p, Initial residual = 0.000871654, Final residual = 7.07252e-07, No Iterations 19
time step continuity errors : sum local = 1.77129e-10, global = -1.46366e-11, cumulative = 5.55914e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148835, Final residual = 3.5212e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00156081, Final residual = 3.50657e-06, No Iterations 5
ExecutionTime = 29.18 s ClockTime = 29 s
Time = 2.87
Courant Number mean: 0.132122 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000790377, Final residual = 3.1491e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00224333, Final residual = 3.32949e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00389731, Final residual = 0.000272573, No Iterations 5
time step continuity errors : sum local = 6.82317e-08, global = 6.70808e-09, cumulative = 5.56585e-06
GAMG: Solving for p, Initial residual = 0.000855677, Final residual = 7.65165e-07, No Iterations 19
time step continuity errors : sum local = 1.91364e-10, global = -1.65807e-11, cumulative = 5.56583e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148716, Final residual = 3.54566e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00155891, Final residual = 3.53116e-06, No Iterations 5
ExecutionTime = 29.2 s ClockTime = 29 s
Time = 2.8725
Courant Number mean: 0.132068 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000789666, Final residual = 3.17822e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00223909, Final residual = 3.35373e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00393432, Final residual = 0.000272048, No Iterations 5
time step continuity errors : sum local = 6.79925e-08, global = 6.68673e-09, cumulative = 5.57252e-06
GAMG: Solving for p, Initial residual = 0.000859769, Final residual = 8.11367e-07, No Iterations 19
time step continuity errors : sum local = 2.02594e-10, global = -1.85201e-11, cumulative = 5.5725e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148591, Final residual = 3.57121e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00155698, Final residual = 3.55665e-06, No Iterations 5
ExecutionTime = 29.23 s ClockTime = 29 s
Time = 2.875
Courant Number mean: 0.132014 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000788832, Final residual = 3.2076e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00223549, Final residual = 3.38275e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00373605, Final residual = 0.000274225, No Iterations 5
time step continuity errors : sum local = 6.84374e-08, global = 6.73772e-09, cumulative = 5.57924e-06
GAMG: Solving for p, Initial residual = 0.000839031, Final residual = 8.27512e-07, No Iterations 19
time step continuity errors : sum local = 2.06342e-10, global = -1.87583e-11, cumulative = 5.57922e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148484, Final residual = 3.59607e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00155492, Final residual = 3.58182e-06, No Iterations 5
ExecutionTime = 29.25 s ClockTime = 29 s
Time = 2.8775
Courant Number mean: 0.131959 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000788224, Final residual = 3.23753e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00223159, Final residual = 3.41091e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00371452, Final residual = 0.000275812, No Iterations 5
time step continuity errors : sum local = 6.87543e-08, global = 6.78696e-09, cumulative = 5.58601e-06
GAMG: Solving for p, Initial residual = 0.000836849, Final residual = 8.44493e-07, No Iterations 19
time step continuity errors : sum local = 2.10342e-10, global = -1.92527e-11, cumulative = 5.58599e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148418, Final residual = 3.62253e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00155276, Final residual = 3.60796e-06, No Iterations 5
ExecutionTime = 29.29 s ClockTime = 30 s
Time = 2.88
Courant Number mean: 0.131907 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.00078769, Final residual = 3.26801e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00222716, Final residual = 3.43964e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00387872, Final residual = 0.000276152, No Iterations 5
time step continuity errors : sum local = 6.87299e-08, global = 6.82431e-09, cumulative = 5.59281e-06
GAMG: Solving for p, Initial residual = 0.000855871, Final residual = 8.35777e-07, No Iterations 19
time step continuity errors : sum local = 2.07825e-10, global = -1.86831e-11, cumulative = 5.59279e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148344, Final residual = 3.64844e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00155085, Final residual = 3.63388e-06, No Iterations 5
ExecutionTime = 29.32 s ClockTime = 30 s
Time = 2.8825
Courant Number mean: 0.131857 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000787167, Final residual = 3.29877e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00222253, Final residual = 3.46855e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.003889, Final residual = 0.000277509, No Iterations 5
time step continuity errors : sum local = 6.89914e-08, global = 6.80475e-09, cumulative = 5.5996e-06
GAMG: Solving for p, Initial residual = 0.00084336, Final residual = 8.62829e-07, No Iterations 19
time step continuity errors : sum local = 2.14333e-10, global = -1.93373e-11, cumulative = 5.59958e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148262, Final residual = 3.67614e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0015491, Final residual = 3.65954e-06, No Iterations 5
ExecutionTime = 29.35 s ClockTime = 30 s
Time = 2.885
Courant Number mean: 0.131807 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000786604, Final residual = 3.32972e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00221738, Final residual = 3.49745e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00383211, Final residual = 0.000276748, No Iterations 5
time step continuity errors : sum local = 6.87076e-08, global = 6.79843e-09, cumulative = 5.60638e-06
GAMG: Solving for p, Initial residual = 0.000841258, Final residual = 8.79801e-07, No Iterations 19
time step continuity errors : sum local = 2.18221e-10, global = -1.96793e-11, cumulative = 5.60636e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148179, Final residual = 3.70229e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00154717, Final residual = 3.68674e-06, No Iterations 5
ExecutionTime = 29.38 s ClockTime = 30 s
Time = 2.8875
Courant Number mean: 0.131756 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000785915, Final residual = 3.36063e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00221209, Final residual = 3.52693e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00373569, Final residual = 0.000276515, No Iterations 5
time step continuity errors : sum local = 6.85428e-08, global = 6.80677e-09, cumulative = 5.61316e-06
GAMG: Solving for p, Initial residual = 0.000827642, Final residual = 9.02792e-07, No Iterations 19
time step continuity errors : sum local = 2.23577e-10, global = -2.02344e-11, cumulative = 5.61314e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00148062, Final residual = 3.73082e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00154511, Final residual = 3.71557e-06, No Iterations 5
ExecutionTime = 29.4 s ClockTime = 30 s
Time = 2.89
Courant Number mean: 0.131705 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000785167, Final residual = 3.39183e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0022065, Final residual = 3.55662e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00371365, Final residual = 0.000276924, No Iterations 5
time step continuity errors : sum local = 6.85307e-08, global = 6.81471e-09, cumulative = 5.61996e-06
GAMG: Solving for p, Initial residual = 0.000838774, Final residual = 9.19662e-07, No Iterations 19
time step continuity errors : sum local = 2.27371e-10, global = -2.06507e-11, cumulative = 5.61994e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147933, Final residual = 3.75745e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00154305, Final residual = 3.7429e-06, No Iterations 5
ExecutionTime = 29.43 s ClockTime = 30 s
Time = 2.8925
Courant Number mean: 0.131652 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000784415, Final residual = 3.4233e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00220042, Final residual = 3.58636e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00378185, Final residual = 0.000280229, No Iterations 5
time step continuity errors : sum local = 6.92311e-08, global = 6.88935e-09, cumulative = 5.62683e-06
GAMG: Solving for p, Initial residual = 0.000849929, Final residual = 9.67545e-07, No Iterations 19
time step continuity errors : sum local = 2.38791e-10, global = -2.22815e-11, cumulative = 5.6268e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147778, Final residual = 3.78483e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00154091, Final residual = 3.77133e-06, No Iterations 5
ExecutionTime = 29.46 s ClockTime = 30 s
Time = 2.895
Courant Number mean: 0.131598 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000783596, Final residual = 3.45428e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00219477, Final residual = 3.61759e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00373874, Final residual = 0.000283169, No Iterations 5
time step continuity errors : sum local = 6.98565e-08, global = 6.9613e-09, cumulative = 5.63376e-06
GAMG: Solving for p, Initial residual = 0.000847586, Final residual = 9.62412e-07, No Iterations 19
time step continuity errors : sum local = 2.37202e-10, global = -2.19429e-11, cumulative = 5.63374e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147604, Final residual = 3.81412e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00153864, Final residual = 3.7993e-06, No Iterations 5
ExecutionTime = 29.49 s ClockTime = 30 s
Time = 2.8975
Courant Number mean: 0.131542 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000782687, Final residual = 3.48594e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00219007, Final residual = 3.6491e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0036455, Final residual = 0.000283837, No Iterations 5
time step continuity errors : sum local = 6.99143e-08, global = 7.02343e-09, cumulative = 5.64077e-06
GAMG: Solving for p, Initial residual = 0.000834706, Final residual = 9.73644e-07, No Iterations 19
time step continuity errors : sum local = 2.39624e-10, global = -2.21542e-11, cumulative = 5.64074e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147396, Final residual = 3.84308e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00153641, Final residual = 3.83014e-06, No Iterations 5
ExecutionTime = 29.52 s ClockTime = 30 s
Time = 2.9
Courant Number mean: 0.131485 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000781696, Final residual = 3.51765e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00218529, Final residual = 3.68134e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00369799, Final residual = 0.000284742, No Iterations 5
time step continuity errors : sum local = 7.00465e-08, global = 7.06184e-09, cumulative = 5.64781e-06
GAMG: Solving for p, Initial residual = 0.000836694, Final residual = 9.87919e-07, No Iterations 19
time step continuity errors : sum local = 2.42821e-10, global = -2.23753e-11, cumulative = 5.64778e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147217, Final residual = 3.87289e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00153427, Final residual = 3.85892e-06, No Iterations 5
ExecutionTime = 29.57 s ClockTime = 30 s
Time = 2.9025
Courant Number mean: 0.131426 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000780705, Final residual = 3.54941e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0021803, Final residual = 3.71381e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00380573, Final residual = 0.000285451, No Iterations 5
time step continuity errors : sum local = 7.01082e-08, global = 7.08464e-09, cumulative = 5.65487e-06
GAMG: Solving for p, Initial residual = 0.000856276, Final residual = 6.20115e-07, No Iterations 21
time step continuity errors : sum local = 1.5215e-10, global = -1.45289e-11, cumulative = 5.65485e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00147043, Final residual = 3.90328e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.001532, Final residual = 3.88965e-06, No Iterations 5
ExecutionTime = 29.6 s ClockTime = 30 s
Time = 2.905
Courant Number mean: 0.131366 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000779654, Final residual = 3.58162e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00217533, Final residual = 3.74674e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00396453, Final residual = 0.000285806, No Iterations 5
time step continuity errors : sum local = 7.00876e-08, global = 7.12014e-09, cumulative = 5.66197e-06
GAMG: Solving for p, Initial residual = 0.000875913, Final residual = 6.38607e-07, No Iterations 21
time step continuity errors : sum local = 1.56438e-10, global = -1.49248e-11, cumulative = 5.66196e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014689, Final residual = 3.9359e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00152953, Final residual = 3.92009e-06, No Iterations 5
ExecutionTime = 29.64 s ClockTime = 30 s
Time = 2.9075
Courant Number mean: 0.131303 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000778642, Final residual = 3.61386e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00216984, Final residual = 3.7799e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00409923, Final residual = 0.000286715, No Iterations 5
time step continuity errors : sum local = 7.01844e-08, global = 7.15462e-09, cumulative = 5.66911e-06
GAMG: Solving for p, Initial residual = 0.000891888, Final residual = 6.84959e-07, No Iterations 21
time step continuity errors : sum local = 1.67511e-10, global = -1.66143e-11, cumulative = 5.6691e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146732, Final residual = 3.96501e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00152698, Final residual = 3.95037e-06, No Iterations 5
ExecutionTime = 29.66 s ClockTime = 30 s
Time = 2.91
Courant Number mean: 0.13124 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000777583, Final residual = 3.64735e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00216408, Final residual = 3.8131e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00391336, Final residual = 0.000287794, No Iterations 5
time step continuity errors : sum local = 7.03251e-08, global = 7.21179e-09, cumulative = 5.67631e-06
GAMG: Solving for p, Initial residual = 0.000860667, Final residual = 6.97074e-07, No Iterations 21
time step continuity errors : sum local = 1.70196e-10, global = -1.67592e-11, cumulative = 5.67629e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146567, Final residual = 3.9968e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00152457, Final residual = 3.97995e-06, No Iterations 5
ExecutionTime = 29.69 s ClockTime = 30 s
Time = 2.9125
Courant Number mean: 0.131174 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000776473, Final residual = 3.6813e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00215858, Final residual = 3.84683e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0038788, Final residual = 0.00028775, No Iterations 5
time step continuity errors : sum local = 7.02156e-08, global = 7.23802e-09, cumulative = 5.68353e-06
GAMG: Solving for p, Initial residual = 0.000847921, Final residual = 7.11065e-07, No Iterations 21
time step continuity errors : sum local = 1.73391e-10, global = -1.71292e-11, cumulative = 5.68351e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146396, Final residual = 4.0279e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00152209, Final residual = 4.01253e-06, No Iterations 5
ExecutionTime = 29.72 s ClockTime = 30 s
Time = 2.915
Courant Number mean: 0.131107 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000775236, Final residual = 3.71535e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00215245, Final residual = 3.88075e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00383747, Final residual = 0.000288147, No Iterations 5
time step continuity errors : sum local = 7.02549e-08, global = 7.24472e-09, cumulative = 5.69076e-06
GAMG: Solving for p, Initial residual = 0.000859112, Final residual = 7.42049e-07, No Iterations 21
time step continuity errors : sum local = 1.8079e-10, global = -1.80772e-11, cumulative = 5.69074e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00146188, Final residual = 4.05983e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00151954, Final residual = 4.0458e-06, No Iterations 5
ExecutionTime = 29.75 s ClockTime = 30 s
Time = 2.9175
Courant Number mean: 0.13104 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000774001, Final residual = 3.75003e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00214672, Final residual = 3.91479e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00373222, Final residual = 0.000289342, No Iterations 5
time step continuity errors : sum local = 7.04768e-08, global = 7.31031e-09, cumulative = 5.69805e-06
GAMG: Solving for p, Initial residual = 0.000828495, Final residual = 7.49725e-07, No Iterations 21
time step continuity errors : sum local = 1.82477e-10, global = -1.83183e-11, cumulative = 5.69803e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145965, Final residual = 4.09323e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00151699, Final residual = 4.07933e-06, No Iterations 5
ExecutionTime = 29.78 s ClockTime = 30 s
Time = 2.92
Courant Number mean: 0.130971 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.00077278, Final residual = 3.7852e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0021408, Final residual = 3.94896e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0036984, Final residual = 0.000289097, No Iterations 5
time step continuity errors : sum local = 7.03277e-08, global = 7.28569e-09, cumulative = 5.70532e-06
GAMG: Solving for p, Initial residual = 0.000824802, Final residual = 7.84028e-07, No Iterations 21
time step continuity errors : sum local = 1.90589e-10, global = -1.91987e-11, cumulative = 5.7053e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145714, Final residual = 4.12774e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00151423, Final residual = 4.11295e-06, No Iterations 5
ExecutionTime = 29.81 s ClockTime = 30 s
Time = 2.9225
Courant Number mean: 0.130904 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000771669, Final residual = 3.82002e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00213431, Final residual = 3.98332e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00390147, Final residual = 0.000289288, No Iterations 5
time step continuity errors : sum local = 7.02587e-08, global = 7.30897e-09, cumulative = 5.71261e-06
GAMG: Solving for p, Initial residual = 0.000845928, Final residual = 7.97478e-07, No Iterations 21
time step continuity errors : sum local = 1.93479e-10, global = -1.93891e-11, cumulative = 5.71259e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00145448, Final residual = 4.16133e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00151142, Final residual = 4.1456e-06, No Iterations 5
ExecutionTime = 29.84 s ClockTime = 30 s
Time = 2.925
Courant Number mean: 0.130837 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000770492, Final residual = 3.85469e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00212837, Final residual = 4.01813e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00392488, Final residual = 0.000290387, No Iterations 5
time step continuity errors : sum local = 7.03951e-08, global = 7.32237e-09, cumulative = 5.71991e-06
GAMG: Solving for p, Initial residual = 0.000843536, Final residual = 8.34729e-07, No Iterations 21
time step continuity errors : sum local = 2.02176e-10, global = -2.04302e-11, cumulative = 5.71989e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014518, Final residual = 4.19447e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00150846, Final residual = 4.17892e-06, No Iterations 5
ExecutionTime = 29.86 s ClockTime = 30 s
Time = 2.9275
Courant Number mean: 0.130769 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000769246, Final residual = 3.8893e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00212282, Final residual = 4.05342e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00403075, Final residual = 0.000291226, No Iterations 5
time step continuity errors : sum local = 7.04983e-08, global = 7.35379e-09, cumulative = 5.72724e-06
GAMG: Solving for p, Initial residual = 0.000856485, Final residual = 8.49101e-07, No Iterations 21
time step continuity errors : sum local = 2.05382e-10, global = -2.06151e-11, cumulative = 5.72722e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144914, Final residual = 4.2281e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00150534, Final residual = 4.21245e-06, No Iterations 5
ExecutionTime = 29.89 s ClockTime = 30 s
Time = 2.93
Courant Number mean: 0.130701 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000767946, Final residual = 3.92473e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00211766, Final residual = 4.08859e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00379267, Final residual = 0.00029147, No Iterations 5
time step continuity errors : sum local = 7.04599e-08, global = 7.35981e-09, cumulative = 5.73458e-06
GAMG: Solving for p, Initial residual = 0.00084725, Final residual = 8.69627e-07, No Iterations 21
time step continuity errors : sum local = 2.10077e-10, global = -2.11962e-11, cumulative = 5.73456e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144635, Final residual = 4.26463e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00150223, Final residual = 4.24722e-06, No Iterations 5
ExecutionTime = 29.92 s ClockTime = 30 s
Time = 2.9325
Courant Number mean: 0.130631 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000766729, Final residual = 3.96044e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0021128, Final residual = 4.12417e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0036231, Final residual = 0.000291935, No Iterations 5
time step continuity errors : sum local = 7.04961e-08, global = 7.38761e-09, cumulative = 5.74195e-06
GAMG: Solving for p, Initial residual = 0.000845873, Final residual = 8.86877e-07, No Iterations 21
time step continuity errors : sum local = 2.14023e-10, global = -2.15691e-11, cumulative = 5.74193e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0014438, Final residual = 4.29861e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00149921, Final residual = 4.28247e-06, No Iterations 5
ExecutionTime = 29.94 s ClockTime = 30 s
Time = 2.935
Courant Number mean: 0.130561 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000765474, Final residual = 3.99622e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00210803, Final residual = 4.16031e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00373822, Final residual = 0.000294278, No Iterations 5
time step continuity errors : sum local = 7.09976e-08, global = 7.42766e-09, cumulative = 5.74935e-06
GAMG: Solving for p, Initial residual = 0.000856429, Final residual = 9.002e-07, No Iterations 21
time step continuity errors : sum local = 2.17045e-10, global = -2.17304e-11, cumulative = 5.74933e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00144123, Final residual = 4.33008e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00149612, Final residual = 4.316e-06, No Iterations 5
ExecutionTime = 29.97 s ClockTime = 30 s
Time = 2.9375
Courant Number mean: 0.130489 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000764136, Final residual = 4.03246e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00210295, Final residual = 4.19647e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00361441, Final residual = 0.000297773, No Iterations 5
time step continuity errors : sum local = 7.17521e-08, global = 7.5108e-09, cumulative = 5.75684e-06
GAMG: Solving for p, Initial residual = 0.000844654, Final residual = 9.23552e-07, No Iterations 21
time step continuity errors : sum local = 2.22355e-10, global = -2.24536e-11, cumulative = 5.75682e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143844, Final residual = 4.36552e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00149301, Final residual = 4.35094e-06, No Iterations 5
ExecutionTime = 30 s ClockTime = 30 s
Time = 2.94
Courant Number mean: 0.130416 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000762973, Final residual = 4.06895e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00209774, Final residual = 4.23306e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00365742, Final residual = 0.000301075, No Iterations 5
time step continuity errors : sum local = 7.24195e-08, global = 7.59493e-09, cumulative = 5.76442e-06
GAMG: Solving for p, Initial residual = 0.000857675, Final residual = 9.40024e-07, No Iterations 21
time step continuity errors : sum local = 2.25876e-10, global = -2.27149e-11, cumulative = 5.76439e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143567, Final residual = 4.39914e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00148984, Final residual = 4.38594e-06, No Iterations 5
ExecutionTime = 30.03 s ClockTime = 30 s
Time = 2.9425
Courant Number mean: 0.130343 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000761927, Final residual = 4.1058e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00209212, Final residual = 4.27002e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00361348, Final residual = 0.000302241, No Iterations 5
time step continuity errors : sum local = 7.25608e-08, global = 7.62585e-09, cumulative = 5.77202e-06
GAMG: Solving for p, Initial residual = 0.000855477, Final residual = 9.59328e-07, No Iterations 21
time step continuity errors : sum local = 2.30105e-10, global = -2.31053e-11, cumulative = 5.772e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00143263, Final residual = 4.43519e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00148666, Final residual = 4.42224e-06, No Iterations 5
ExecutionTime = 30.05 s ClockTime = 30 s
Time = 2.945
Courant Number mean: 0.130268 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000760879, Final residual = 4.1433e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00208605, Final residual = 4.30741e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00354774, Final residual = 0.000302854, No Iterations 5
time step continuity errors : sum local = 7.25809e-08, global = 7.64747e-09, cumulative = 5.77964e-06
GAMG: Solving for p, Initial residual = 0.000846431, Final residual = 9.80137e-07, No Iterations 21
time step continuity errors : sum local = 2.34707e-10, global = -2.36216e-11, cumulative = 5.77962e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142954, Final residual = 4.47063e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00148327, Final residual = 4.45736e-06, No Iterations 5
ExecutionTime = 30.08 s ClockTime = 30 s
Time = 2.9475
Courant Number mean: 0.130191 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000759743, Final residual = 4.18069e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00207982, Final residual = 4.34506e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00367276, Final residual = 0.000302636, No Iterations 5
time step continuity errors : sum local = 7.24198e-08, global = 7.67124e-09, cumulative = 5.78729e-06
GAMG: Solving for p, Initial residual = 0.000850467, Final residual = 9.88229e-07, No Iterations 21
time step continuity errors : sum local = 2.36274e-10, global = -2.3647e-11, cumulative = 5.78727e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142611, Final residual = 4.50726e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00147982, Final residual = 4.49298e-06, No Iterations 5
ExecutionTime = 30.12 s ClockTime = 30 s
Time = 2.95
Courant Number mean: 0.130114 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000758536, Final residual = 4.21767e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00207328, Final residual = 4.38312e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00388747, Final residual = 0.000303422, No Iterations 5
time step continuity errors : sum local = 7.25024e-08, global = 7.692e-09, cumulative = 5.79496e-06
GAMG: Solving for p, Initial residual = 0.000873501, Final residual = 9.96614e-07, No Iterations 21
time step continuity errors : sum local = 2.37961e-10, global = -2.37898e-11, cumulative = 5.79494e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00142232, Final residual = 4.54542e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00147639, Final residual = 4.52903e-06, No Iterations 5
ExecutionTime = 30.15 s ClockTime = 30 s
Time = 2.9525
Courant Number mean: 0.130035 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000757231, Final residual = 4.2543e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00206614, Final residual = 4.42128e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00378448, Final residual = 0.000304598, No Iterations 5
time step continuity errors : sum local = 7.26927e-08, global = 7.71083e-09, cumulative = 5.80265e-06
GAMG: Solving for p, Initial residual = 0.000861614, Final residual = 6.36227e-07, No Iterations 23
time step continuity errors : sum local = 1.51725e-10, global = -1.54537e-11, cumulative = 5.80263e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141846, Final residual = 4.57966e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00147282, Final residual = 4.5657e-06, No Iterations 5
ExecutionTime = 30.18 s ClockTime = 30 s
Time = 2.955
Courant Number mean: 0.129955 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000755862, Final residual = 4.29068e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00205882, Final residual = 4.45934e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00369497, Final residual = 0.000305164, No Iterations 5
time step continuity errors : sum local = 7.27081e-08, global = 7.71118e-09, cumulative = 5.81034e-06
GAMG: Solving for p, Initial residual = 0.000857434, Final residual = 6.44825e-07, No Iterations 23
time step continuity errors : sum local = 1.53503e-10, global = -1.5714e-11, cumulative = 5.81033e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141467, Final residual = 4.617e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00146918, Final residual = 4.60304e-06, No Iterations 5
ExecutionTime = 30.2 s ClockTime = 30 s
Time = 2.9575
Courant Number mean: 0.129875 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000754491, Final residual = 4.32681e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00205128, Final residual = 4.49756e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00413386, Final residual = 0.000305486, No Iterations 5
time step continuity errors : sum local = 7.26664e-08, global = 7.73216e-09, cumulative = 5.81806e-06
GAMG: Solving for p, Initial residual = 0.000910689, Final residual = 6.47719e-07, No Iterations 23
time step continuity errors : sum local = 1.53944e-10, global = -1.5683e-11, cumulative = 5.81804e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00141089, Final residual = 4.6537e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00146541, Final residual = 4.6404e-06, No Iterations 5
ExecutionTime = 30.23 s ClockTime = 30 s
Time = 2.96
Courant Number mean: 0.129794 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000753047, Final residual = 4.36256e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00204405, Final residual = 4.53571e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00374919, Final residual = 0.000306722, No Iterations 5
time step continuity errors : sum local = 7.28445e-08, global = 7.74031e-09, cumulative = 5.82578e-06
GAMG: Solving for p, Initial residual = 0.000862976, Final residual = 6.61032e-07, No Iterations 23
time step continuity errors : sum local = 1.56882e-10, global = -1.60401e-11, cumulative = 5.82577e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140718, Final residual = 4.69024e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00146157, Final residual = 4.68025e-06, No Iterations 5
ExecutionTime = 30.26 s ClockTime = 30 s
Time = 2.9625
Courant Number mean: 0.129713 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000751564, Final residual = 4.39812e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00203733, Final residual = 4.5736e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00372778, Final residual = 0.000304326, No Iterations 5
time step continuity errors : sum local = 7.21512e-08, global = 7.73451e-09, cumulative = 5.8335e-06
GAMG: Solving for p, Initial residual = 0.000869546, Final residual = 6.61037e-07, No Iterations 23
time step continuity errors : sum local = 1.566e-10, global = -1.58775e-11, cumulative = 5.83349e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140373, Final residual = 4.73253e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00145775, Final residual = 4.71936e-06, No Iterations 5
ExecutionTime = 30.29 s ClockTime = 31 s
Time = 2.965
Courant Number mean: 0.129632 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000750111, Final residual = 4.43338e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00203079, Final residual = 4.61133e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0037259, Final residual = 0.000304545, No Iterations 5
time step continuity errors : sum local = 7.2076e-08, global = 7.72975e-09, cumulative = 5.84122e-06
GAMG: Solving for p, Initial residual = 0.000866628, Final residual = 6.6907e-07, No Iterations 23
time step continuity errors : sum local = 1.58211e-10, global = -1.60092e-11, cumulative = 5.8412e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00140004, Final residual = 4.76995e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00145397, Final residual = 4.75867e-06, No Iterations 5
ExecutionTime = 30.32 s ClockTime = 31 s
Time = 2.9675
Courant Number mean: 0.129551 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00074858, Final residual = 4.4688e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00202423, Final residual = 4.64876e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00352572, Final residual = 0.000305568, No Iterations 5
time step continuity errors : sum local = 7.22381e-08, global = 7.73705e-09, cumulative = 5.84894e-06
GAMG: Solving for p, Initial residual = 0.000849289, Final residual = 6.78652e-07, No Iterations 23
time step continuity errors : sum local = 1.60338e-10, global = -1.61793e-11, cumulative = 5.84892e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139617, Final residual = 4.81182e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0014503, Final residual = 4.79733e-06, No Iterations 5
ExecutionTime = 30.34 s ClockTime = 31 s
Time = 2.97
Courant Number mean: 0.129468 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000746969, Final residual = 4.50469e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00201765, Final residual = 4.68575e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00339345, Final residual = 0.0003046, No Iterations 5
time step continuity errors : sum local = 7.19224e-08, global = 7.72627e-09, cumulative = 5.85665e-06
GAMG: Solving for p, Initial residual = 0.000846237, Final residual = 6.84683e-07, No Iterations 23
time step continuity errors : sum local = 1.61574e-10, global = -1.62205e-11, cumulative = 5.85663e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00139213, Final residual = 4.85273e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00144655, Final residual = 4.83648e-06, No Iterations 5
ExecutionTime = 30.38 s ClockTime = 31 s
Time = 2.9725
Courant Number mean: 0.129385 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00074525, Final residual = 4.54132e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00201102, Final residual = 4.72242e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00354436, Final residual = 0.000304507, No Iterations 5
time step continuity errors : sum local = 7.1796e-08, global = 7.73629e-09, cumulative = 5.86437e-06
GAMG: Solving for p, Initial residual = 0.000859606, Final residual = 6.8233e-07, No Iterations 23
time step continuity errors : sum local = 1.60763e-10, global = -1.60167e-11, cumulative = 5.86435e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00138792, Final residual = 4.88694e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00144272, Final residual = 4.87606e-06, No Iterations 5
ExecutionTime = 30.4 s ClockTime = 31 s
Time = 2.975
Courant Number mean: 0.1293 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000743439, Final residual = 4.57805e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0020042, Final residual = 4.75908e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00358866, Final residual = 0.000303365, No Iterations 5
time step continuity errors : sum local = 7.14098e-08, global = 7.71784e-09, cumulative = 5.87207e-06
GAMG: Solving for p, Initial residual = 0.000863079, Final residual = 6.90806e-07, No Iterations 23
time step continuity errors : sum local = 1.62496e-10, global = -1.60949e-11, cumulative = 5.87205e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00138344, Final residual = 4.92579e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00143867, Final residual = 4.91694e-06, No Iterations 5
ExecutionTime = 30.43 s ClockTime = 31 s
Time = 2.9775
Courant Number mean: 0.129214 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00074184, Final residual = 4.61441e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00199727, Final residual = 4.7991e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0038291, Final residual = 0.000303182, No Iterations 5
time step continuity errors : sum local = 7.12362e-08, global = 7.7194e-09, cumulative = 5.87977e-06
GAMG: Solving for p, Initial residual = 0.000885989, Final residual = 7.04106e-07, No Iterations 23
time step continuity errors : sum local = 1.6532e-10, global = -1.63482e-11, cumulative = 5.87976e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00137877, Final residual = 4.96508e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00143454, Final residual = 4.95703e-06, No Iterations 5
ExecutionTime = 30.46 s ClockTime = 31 s
Time = 2.98
Courant Number mean: 0.129128 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000740321, Final residual = 4.65019e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00199018, Final residual = 4.84171e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.003824, Final residual = 0.000301468, No Iterations 5
time step continuity errors : sum local = 7.07348e-08, global = 7.68678e-09, cumulative = 5.88744e-06
GAMG: Solving for p, Initial residual = 0.000890254, Final residual = 7.17889e-07, No Iterations 23
time step continuity errors : sum local = 1.68343e-10, global = -1.66662e-11, cumulative = 5.88743e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00137421, Final residual = 5.0032e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00143036, Final residual = 4.99824e-06, No Iterations 5
ExecutionTime = 30.49 s ClockTime = 31 s
Time = 2.9825
Courant Number mean: 0.12904 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000738765, Final residual = 4.68543e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00198298, Final residual = 4.88481e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00358868, Final residual = 0.00030093, No Iterations 5
time step continuity errors : sum local = 7.05221e-08, global = 7.69433e-09, cumulative = 5.89512e-06
GAMG: Solving for p, Initial residual = 0.000865124, Final residual = 7.24926e-07, No Iterations 23
time step continuity errors : sum local = 1.69808e-10, global = -1.67766e-11, cumulative = 5.8951e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136955, Final residual = 5.04216e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0014261, Final residual = 5.03898e-06, No Iterations 5
ExecutionTime = 30.51 s ClockTime = 31 s
Time = 2.985
Courant Number mean: 0.128951 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000737177, Final residual = 4.72061e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00197553, Final residual = 4.92795e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00354724, Final residual = 0.000299114, No Iterations 5
time step continuity errors : sum local = 7.00477e-08, global = 7.67795e-09, cumulative = 5.90278e-06
GAMG: Solving for p, Initial residual = 0.000857402, Final residual = 7.36183e-07, No Iterations 23
time step continuity errors : sum local = 1.7233e-10, global = -1.70023e-11, cumulative = 5.90276e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136482, Final residual = 5.07847e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0014217, Final residual = 5.07883e-06, No Iterations 5
ExecutionTime = 30.54 s ClockTime = 31 s
Time = 2.9875
Courant Number mean: 0.128861 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000735503, Final residual = 4.7556e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0019685, Final residual = 4.97134e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00343907, Final residual = 0.000296694, No Iterations 5
time step continuity errors : sum local = 6.94057e-08, global = 7.64113e-09, cumulative = 5.91041e-06
GAMG: Solving for p, Initial residual = 0.000857484, Final residual = 7.51738e-07, No Iterations 23
time step continuity errors : sum local = 1.75761e-10, global = -1.73829e-11, cumulative = 5.91039e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00136018, Final residual = 5.11355e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00141733, Final residual = 5.11882e-06, No Iterations 5
ExecutionTime = 30.57 s ClockTime = 31 s
Time = 2.99
Courant Number mean: 0.12877 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000733809, Final residual = 4.79043e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00196148, Final residual = 5.01533e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00339878, Final residual = 0.000295526, No Iterations 5
time step continuity errors : sum local = 6.90465e-08, global = 7.60323e-09, cumulative = 5.91799e-06
GAMG: Solving for p, Initial residual = 0.000859342, Final residual = 7.52511e-07, No Iterations 23
time step continuity errors : sum local = 1.75735e-10, global = -1.72363e-11, cumulative = 5.91797e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00135551, Final residual = 5.15516e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00141284, Final residual = 5.15807e-06, No Iterations 5
ExecutionTime = 30.6 s ClockTime = 31 s
Time = 2.9925
Courant Number mean: 0.128678 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000732091, Final residual = 4.82479e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00195476, Final residual = 5.05952e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00341412, Final residual = 0.000294047, No Iterations 5
time step continuity errors : sum local = 6.86075e-08, global = 7.57576e-09, cumulative = 5.92555e-06
GAMG: Solving for p, Initial residual = 0.000862546, Final residual = 7.63416e-07, No Iterations 23
time step continuity errors : sum local = 1.78023e-10, global = -1.7434e-11, cumulative = 5.92553e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00135083, Final residual = 5.19429e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00140833, Final residual = 5.19988e-06, No Iterations 5
ExecutionTime = 30.62 s ClockTime = 31 s
Time = 2.995
Courant Number mean: 0.128586 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000730396, Final residual = 4.85868e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00194918, Final residual = 5.10414e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00353674, Final residual = 0.000292948, No Iterations 5
time step continuity errors : sum local = 6.82389e-08, global = 7.54921e-09, cumulative = 5.93308e-06
GAMG: Solving for p, Initial residual = 0.000874696, Final residual = 7.78659e-07, No Iterations 23
time step continuity errors : sum local = 1.81258e-10, global = -1.77637e-11, cumulative = 5.93306e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013461, Final residual = 5.22274e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00140384, Final residual = 5.23915e-06, No Iterations 5
ExecutionTime = 30.65 s ClockTime = 31 s
Time = 2.9975
Courant Number mean: 0.128492 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00072884, Final residual = 4.89231e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00194358, Final residual = 5.14874e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00356841, Final residual = 0.000292495, No Iterations 5
time step continuity errors : sum local = 6.80126e-08, global = 7.52645e-09, cumulative = 5.94059e-06
GAMG: Solving for p, Initial residual = 0.000870819, Final residual = 7.96128e-07, No Iterations 23
time step continuity errors : sum local = 1.8502e-10, global = -1.82078e-11, cumulative = 5.94057e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00134124, Final residual = 5.26131e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00139938, Final residual = 5.27896e-06, No Iterations 5
ExecutionTime = 30.68 s ClockTime = 31 s
Time = 3
Courant Number mean: 0.128398 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000727391, Final residual = 4.92558e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00193793, Final residual = 5.19358e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00361313, Final residual = 0.000293553, No Iterations 5
time step continuity errors : sum local = 6.81902e-08, global = 7.50801e-09, cumulative = 5.94808e-06
GAMG: Solving for p, Initial residual = 0.000880348, Final residual = 8.08737e-07, No Iterations 23
time step continuity errors : sum local = 1.87805e-10, global = -1.85546e-11, cumulative = 5.94806e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00133619, Final residual = 5.29369e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00139502, Final residual = 5.31822e-06, No Iterations 5
ExecutionTime = 30.74 s ClockTime = 31 s
Time = 3.0025
Courant Number mean: 0.128303 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000725976, Final residual = 4.95835e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0019319, Final residual = 5.23811e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00357759, Final residual = 0.000290008, No Iterations 5
time step continuity errors : sum local = 6.73189e-08, global = 7.43896e-09, cumulative = 5.9555e-06
GAMG: Solving for p, Initial residual = 0.000873029, Final residual = 8.11315e-07, No Iterations 23
time step continuity errors : sum local = 1.88298e-10, global = -1.84883e-11, cumulative = 5.95548e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00133094, Final residual = 5.32816e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00139053, Final residual = 5.35822e-06, No Iterations 5
ExecutionTime = 30.77 s ClockTime = 31 s
Time = 3.005
Courant Number mean: 0.128207 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000724451, Final residual = 4.99112e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0019257, Final residual = 5.28243e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00344585, Final residual = 0.000288408, No Iterations 5
time step continuity errors : sum local = 6.69023e-08, global = 7.40356e-09, cumulative = 5.96289e-06
GAMG: Solving for p, Initial residual = 0.000861998, Final residual = 8.19397e-07, No Iterations 23
time step continuity errors : sum local = 1.90078e-10, global = -1.86357e-11, cumulative = 5.96287e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00132556, Final residual = 5.367e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00138595, Final residual = 5.39714e-06, No Iterations 5
ExecutionTime = 30.8 s ClockTime = 31 s
Time = 3.0075
Courant Number mean: 0.12811 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00072281, Final residual = 5.02427e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00191947, Final residual = 5.32622e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0036124, Final residual = 0.000359836, No Iterations 4
time step continuity errors : sum local = 8.34172e-08, global = -9.32272e-09, cumulative = 5.95354e-06
GAMG: Solving for p, Initial residual = 0.000854108, Final residual = 8.99143e-07, No Iterations 22
time step continuity errors : sum local = 2.08388e-10, global = -2.3611e-11, cumulative = 5.95352e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00132026, Final residual = 5.39701e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00138134, Final residual = 5.43754e-06, No Iterations 5
ExecutionTime = 30.83 s ClockTime = 31 s
Time = 3.01
Courant Number mean: 0.128013 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00072129, Final residual = 5.05705e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00191259, Final residual = 5.36614e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00365102, Final residual = 0.00034107, No Iterations 4
time step continuity errors : sum local = 7.89939e-08, global = -8.7698e-09, cumulative = 5.94475e-06
GAMG: Solving for p, Initial residual = 0.000842771, Final residual = 8.50278e-07, No Iterations 22
time step continuity errors : sum local = 1.96829e-10, global = -2.13176e-11, cumulative = 5.94473e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0013148, Final residual = 5.42745e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00137662, Final residual = 5.47581e-06, No Iterations 5
ExecutionTime = 30.86 s ClockTime = 31 s
Time = 3.0125
Courant Number mean: 0.127914 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000719642, Final residual = 5.08824e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00190651, Final residual = 5.4094e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00359726, Final residual = 0.000336711, No Iterations 4
time step continuity errors : sum local = 7.78724e-08, global = -8.70099e-09, cumulative = 5.93603e-06
GAMG: Solving for p, Initial residual = 0.000843182, Final residual = 8.43196e-07, No Iterations 22
time step continuity errors : sum local = 1.94891e-10, global = -2.06622e-11, cumulative = 5.93601e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00130956, Final residual = 5.46363e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00137188, Final residual = 5.51918e-06, No Iterations 5
ExecutionTime = 30.88 s ClockTime = 31 s
Time = 3.015
Courant Number mean: 0.127816 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000717942, Final residual = 5.11857e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00190046, Final residual = 5.45398e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00348849, Final residual = 0.000331527, No Iterations 4
time step continuity errors : sum local = 7.65743e-08, global = -8.59402e-09, cumulative = 5.92741e-06
GAMG: Solving for p, Initial residual = 0.00083433, Final residual = 8.54021e-07, No Iterations 22
time step continuity errors : sum local = 1.97163e-10, global = -2.07576e-11, cumulative = 5.92739e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00130422, Final residual = 5.49623e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00136708, Final residual = 5.55708e-06, No Iterations 5
ExecutionTime = 30.91 s ClockTime = 31 s
Time = 3.0175
Courant Number mean: 0.127716 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000716193, Final residual = 5.148e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00189437, Final residual = 5.49988e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00354791, Final residual = 0.000326506, No Iterations 4
time step continuity errors : sum local = 7.53582e-08, global = -8.43627e-09, cumulative = 5.91896e-06
GAMG: Solving for p, Initial residual = 0.000839749, Final residual = 8.66939e-07, No Iterations 22
time step continuity errors : sum local = 2.00028e-10, global = -2.10558e-11, cumulative = 5.91894e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012987, Final residual = 5.52784e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00136226, Final residual = 5.59518e-06, No Iterations 5
ExecutionTime = 30.94 s ClockTime = 31 s
Time = 3.02
Courant Number mean: 0.127616 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00071446, Final residual = 5.17686e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.001888, Final residual = 5.54652e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0035037, Final residual = 0.000320807, No Iterations 4
time step continuity errors : sum local = 7.39733e-08, global = -8.3095e-09, cumulative = 5.91063e-06
GAMG: Solving for p, Initial residual = 0.000840727, Final residual = 8.77598e-07, No Iterations 22
time step continuity errors : sum local = 2.02309e-10, global = -2.11222e-11, cumulative = 5.91061e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00129283, Final residual = 5.55661e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00135733, Final residual = 5.63476e-06, No Iterations 5
ExecutionTime = 30.97 s ClockTime = 31 s
Time = 3.0225
Courant Number mean: 0.127515 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000712697, Final residual = 5.20631e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00188124, Final residual = 5.59368e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00348552, Final residual = 0.000313525, No Iterations 4
time step continuity errors : sum local = 7.22367e-08, global = -8.12025e-09, cumulative = 5.90249e-06
GAMG: Solving for p, Initial residual = 0.000832268, Final residual = 8.85897e-07, No Iterations 22
time step continuity errors : sum local = 2.04089e-10, global = -2.11302e-11, cumulative = 5.90246e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128701, Final residual = 5.59155e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00135248, Final residual = 5.67292e-06, No Iterations 5
ExecutionTime = 31 s ClockTime = 31 s
Time = 3.025
Courant Number mean: 0.127414 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000710977, Final residual = 5.23704e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00187463, Final residual = 5.64096e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0038796, Final residual = 0.000308562, No Iterations 4
time step continuity errors : sum local = 7.1034e-08, global = -7.9572e-09, cumulative = 5.89451e-06
GAMG: Solving for p, Initial residual = 0.000872382, Final residual = 8.99329e-07, No Iterations 22
time step continuity errors : sum local = 2.06981e-10, global = -2.13753e-11, cumulative = 5.89449e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00128117, Final residual = 5.62238e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00134757, Final residual = 5.70943e-06, No Iterations 5
ExecutionTime = 31.05 s ClockTime = 31 s
Time = 3.0275
Courant Number mean: 0.127312 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.0007092, Final residual = 5.26706e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00186844, Final residual = 5.68846e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00388983, Final residual = 0.000300463, No Iterations 4
time step continuity errors : sum local = 6.9102e-08, global = -7.6821e-09, cumulative = 5.8868e-06
GAMG: Solving for p, Initial residual = 0.000875898, Final residual = 9.16244e-07, No Iterations 22
time step continuity errors : sum local = 2.10665e-10, global = -2.16339e-11, cumulative = 5.88678e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00127525, Final residual = 5.65333e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00134272, Final residual = 5.74804e-06, No Iterations 5
ExecutionTime = 31.07 s ClockTime = 31 s
Time = 3.03
Courant Number mean: 0.127209 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000707396, Final residual = 5.29614e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00186254, Final residual = 5.73616e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00365359, Final residual = 0.000293682, No Iterations 4
time step continuity errors : sum local = 6.74704e-08, global = -7.40172e-09, cumulative = 5.87938e-06
GAMG: Solving for p, Initial residual = 0.000855261, Final residual = 9.63167e-07, No Iterations 22
time step continuity errors : sum local = 2.21226e-10, global = -2.29737e-11, cumulative = 5.87936e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00126915, Final residual = 5.68549e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00133791, Final residual = 5.78836e-06, No Iterations 5
ExecutionTime = 31.1 s ClockTime = 31 s
Time = 3.0325
Courant Number mean: 0.127106 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000705632, Final residual = 5.32226e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00185685, Final residual = 5.78653e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00349584, Final residual = 0.000283223, No Iterations 4
time step continuity errors : sum local = 6.50505e-08, global = -7.05364e-09, cumulative = 5.8723e-06
GAMG: Solving for p, Initial residual = 0.000838941, Final residual = 9.39209e-07, No Iterations 22
time step continuity errors : sum local = 2.15658e-10, global = -2.18762e-11, cumulative = 5.87228e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00126326, Final residual = 5.71657e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00133307, Final residual = 5.82307e-06, No Iterations 5
ExecutionTime = 31.13 s ClockTime = 31 s
Time = 3.035
Courant Number mean: 0.127002 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000704005, Final residual = 5.34828e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0018507, Final residual = 5.83847e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.003387, Final residual = 0.000266799, No Iterations 4
time step continuity errors : sum local = 6.12174e-08, global = -6.25641e-09, cumulative = 5.86603e-06
GAMG: Solving for p, Initial residual = 0.000836461, Final residual = 9.51427e-07, No Iterations 22
time step continuity errors : sum local = 2.18283e-10, global = -2.11262e-11, cumulative = 5.866e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125732, Final residual = 5.74091e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00132823, Final residual = 5.85827e-06, No Iterations 5
ExecutionTime = 31.16 s ClockTime = 31 s
Time = 3.0375
Courant Number mean: 0.126898 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000702325, Final residual = 5.37272e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00184477, Final residual = 5.89761e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00321777, Final residual = 0.000262203, No Iterations 4
time step continuity errors : sum local = 6.01184e-08, global = -6.17639e-09, cumulative = 5.85983e-06
GAMG: Solving for p, Initial residual = 0.000827768, Final residual = 9.72239e-07, No Iterations 22
time step continuity errors : sum local = 2.22932e-10, global = -2.18324e-11, cumulative = 5.85981e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00125166, Final residual = 5.77266e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00132326, Final residual = 5.89152e-06, No Iterations 5
ExecutionTime = 31.19 s ClockTime = 31 s
Time = 3.04
Courant Number mean: 0.126794 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000700599, Final residual = 5.39647e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00183866, Final residual = 5.96076e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00345048, Final residual = 0.000255663, No Iterations 4
time step continuity errors : sum local = 5.85786e-08, global = -5.64856e-09, cumulative = 5.85416e-06
GAMG: Solving for p, Initial residual = 0.000847451, Final residual = 6.41827e-07, No Iterations 24
time step continuity errors : sum local = 1.47043e-10, global = -1.55404e-11, cumulative = 5.85414e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00124621, Final residual = 5.80352e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00131843, Final residual = 5.92574e-06, No Iterations 5
ExecutionTime = 31.22 s ClockTime = 31 s
Time = 3.0425
Courant Number mean: 0.126689 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000698866, Final residual = 5.41972e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00183269, Final residual = 6.02755e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00352399, Final residual = 0.000251491, No Iterations 4
time step continuity errors : sum local = 5.75527e-08, global = -5.41722e-09, cumulative = 5.84872e-06
GAMG: Solving for p, Initial residual = 0.000875121, Final residual = 6.55344e-07, No Iterations 24
time step continuity errors : sum local = 1.4992e-10, global = -1.57754e-11, cumulative = 5.84871e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00124095, Final residual = 5.83245e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00131355, Final residual = 5.95709e-06, No Iterations 5
ExecutionTime = 31.24 s ClockTime = 31 s
Time = 3.045
Courant Number mean: 0.126584 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000697144, Final residual = 5.44244e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00182728, Final residual = 6.09646e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00363002, Final residual = 0.00025223, No Iterations 4
time step continuity errors : sum local = 5.76559e-08, global = -4.75101e-09, cumulative = 5.84396e-06
GAMG: Solving for p, Initial residual = 0.000897244, Final residual = 6.72224e-07, No Iterations 24
time step continuity errors : sum local = 1.53629e-10, global = -1.6206e-11, cumulative = 5.84394e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00123575, Final residual = 5.8609e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00130869, Final residual = 5.99042e-06, No Iterations 5
ExecutionTime = 31.27 s ClockTime = 31 s
Time = 3.0475
Courant Number mean: 0.126479 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000695396, Final residual = 5.46461e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00182245, Final residual = 6.16653e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00345871, Final residual = 0.000260255, No Iterations 4
time step continuity errors : sum local = 5.94562e-08, global = -2.63672e-09, cumulative = 5.8413e-06
GAMG: Solving for p, Initial residual = 0.000871121, Final residual = 7.00019e-07, No Iterations 24
time step continuity errors : sum local = 1.59921e-10, global = -1.72013e-11, cumulative = 5.84129e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00123057, Final residual = 5.88826e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00130379, Final residual = 6.02274e-06, No Iterations 5
ExecutionTime = 31.3 s ClockTime = 32 s
Time = 3.05
Courant Number mean: 0.126374 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000693689, Final residual = 5.48578e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00181748, Final residual = 6.2374e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00341432, Final residual = 0.000260053, No Iterations 4
time step continuity errors : sum local = 5.93848e-08, global = -1.42478e-09, cumulative = 5.83986e-06
GAMG: Solving for p, Initial residual = 0.000855296, Final residual = 6.75826e-07, No Iterations 24
time step continuity errors : sum local = 1.54302e-10, global = -1.64852e-11, cumulative = 5.83985e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00122533, Final residual = 5.91154e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00129894, Final residual = 6.05586e-06, No Iterations 5
ExecutionTime = 31.33 s ClockTime = 32 s
Time = 3.0525
Courant Number mean: 0.126269 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000692008, Final residual = 5.50652e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00181317, Final residual = 6.30832e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00345758, Final residual = 0.000256312, No Iterations 4
time step continuity errors : sum local = 5.84833e-08, global = -3.01736e-10, cumulative = 5.83954e-06
GAMG: Solving for p, Initial residual = 0.000864689, Final residual = 9.96979e-07, No Iterations 23
time step continuity errors : sum local = 2.27459e-10, global = 4.83932e-11, cumulative = 5.83959e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00122, Final residual = 5.93968e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00129419, Final residual = 6.08484e-06, No Iterations 5
ExecutionTime = 31.36 s ClockTime = 32 s
Time = 3.055
Courant Number mean: 0.126164 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000690322, Final residual = 5.52686e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00180886, Final residual = 6.37916e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0033832, Final residual = 0.000253976, No Iterations 4
time step continuity errors : sum local = 5.79192e-08, global = 1.51639e-09, cumulative = 5.84111e-06
GAMG: Solving for p, Initial residual = 0.000859333, Final residual = 9.01697e-07, No Iterations 22
time step continuity errors : sum local = 2.05637e-10, global = -2.13884e-11, cumulative = 5.84109e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0012147, Final residual = 5.96677e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0012895, Final residual = 6.11721e-06, No Iterations 5
ExecutionTime = 31.39 s ClockTime = 32 s
Time = 3.0575
Courant Number mean: 0.126058 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000688645, Final residual = 5.54687e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00180445, Final residual = 6.44936e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00319102, Final residual = 0.00024924, No Iterations 4
time step continuity errors : sum local = 5.68137e-08, global = 1.27795e-09, cumulative = 5.84237e-06
GAMG: Solving for p, Initial residual = 0.000847119, Final residual = 9.01717e-07, No Iterations 22
time step continuity errors : sum local = 2.05556e-10, global = -2.16179e-11, cumulative = 5.84234e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00120945, Final residual = 5.99431e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00128483, Final residual = 6.14807e-06, No Iterations 5
ExecutionTime = 31.42 s ClockTime = 32 s
Time = 3.06
Courant Number mean: 0.125953 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000686996, Final residual = 5.56632e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00179998, Final residual = 6.51911e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00320456, Final residual = 0.000244235, No Iterations 4
time step continuity errors : sum local = 5.56342e-08, global = 1.41257e-09, cumulative = 5.84376e-06
GAMG: Solving for p, Initial residual = 0.000851931, Final residual = 8.5518e-07, No Iterations 22
time step continuity errors : sum local = 1.94766e-10, global = -2.03293e-11, cumulative = 5.84374e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00120436, Final residual = 6.02003e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00128027, Final residual = 6.18039e-06, No Iterations 5
ExecutionTime = 31.45 s ClockTime = 32 s
Time = 3.0625
Courant Number mean: 0.125848 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000685292, Final residual = 5.58598e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00179574, Final residual = 6.58754e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00348481, Final residual = 0.000238473, No Iterations 4
time step continuity errors : sum local = 5.43032e-08, global = 2.40633e-09, cumulative = 5.84614e-06
GAMG: Solving for p, Initial residual = 0.000862977, Final residual = 6.84378e-07, No Iterations 22
time step continuity errors : sum local = 1.55813e-10, global = -1.60078e-11, cumulative = 5.84613e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00119957, Final residual = 6.04678e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00127568, Final residual = 6.20973e-06, No Iterations 5
ExecutionTime = 31.47 s ClockTime = 32 s
Time = 3.065
Courant Number mean: 0.125742 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000683568, Final residual = 5.60638e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0017918, Final residual = 6.65443e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00373291, Final residual = 0.000222003, No Iterations 4
time step continuity errors : sum local = 5.05134e-08, global = 3.51424e-09, cumulative = 5.84964e-06
GAMG: Solving for p, Initial residual = 0.000858518, Final residual = 9.14324e-07, No Iterations 21
time step continuity errors : sum local = 2.07975e-10, global = -2.06103e-11, cumulative = 5.84962e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00119506, Final residual = 6.07801e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00127105, Final residual = 6.24477e-06, No Iterations 5
ExecutionTime = 31.5 s ClockTime = 32 s
Time = 3.0675
Courant Number mean: 0.125637 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000681843, Final residual = 5.62652e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00178798, Final residual = 6.72036e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00352206, Final residual = 0.000221582, No Iterations 4
time step continuity errors : sum local = 5.03737e-08, global = 2.88495e-09, cumulative = 5.85251e-06
GAMG: Solving for p, Initial residual = 0.000849153, Final residual = 8.45074e-07, No Iterations 21
time step continuity errors : sum local = 1.92109e-10, global = -1.90736e-11, cumulative = 5.85249e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00119071, Final residual = 6.10849e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00126638, Final residual = 6.27402e-06, No Iterations 5
ExecutionTime = 31.52 s ClockTime = 32 s
Time = 3.07
Courant Number mean: 0.125532 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000680024, Final residual = 5.646e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00178431, Final residual = 6.785e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00331458, Final residual = 0.000213767, No Iterations 4
time step continuity errors : sum local = 4.85734e-08, global = 3.13878e-09, cumulative = 5.85563e-06
GAMG: Solving for p, Initial residual = 0.000823352, Final residual = 9.19726e-07, No Iterations 21
time step continuity errors : sum local = 2.08998e-10, global = -2.12169e-11, cumulative = 5.8556e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00118634, Final residual = 6.14098e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00126177, Final residual = 6.30693e-06, No Iterations 5
ExecutionTime = 31.55 s ClockTime = 32 s
Time = 3.0725
Courant Number mean: 0.125427 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000678198, Final residual = 5.66657e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00178077, Final residual = 6.84797e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00347064, Final residual = 0.000214046, No Iterations 4
time step continuity errors : sum local = 4.86263e-08, global = 2.51222e-09, cumulative = 5.85812e-06
GAMG: Solving for p, Initial residual = 0.000837639, Final residual = 8.51432e-07, No Iterations 21
time step continuity errors : sum local = 1.93438e-10, global = -1.97572e-11, cumulative = 5.8581e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0011818, Final residual = 6.17436e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00125724, Final residual = 6.34104e-06, No Iterations 5
ExecutionTime = 31.59 s ClockTime = 32 s
Time = 3.075
Courant Number mean: 0.125322 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000676357, Final residual = 5.68832e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00177725, Final residual = 6.90947e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.003235, Final residual = 0.000206645, No Iterations 4
time step continuity errors : sum local = 4.69285e-08, global = 2.37667e-09, cumulative = 5.86047e-06
GAMG: Solving for p, Initial residual = 0.000811122, Final residual = 8.64231e-07, No Iterations 21
time step continuity errors : sum local = 1.96269e-10, global = -2.02777e-11, cumulative = 5.86045e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00117745, Final residual = 6.20548e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00125287, Final residual = 6.3728e-06, No Iterations 5
ExecutionTime = 31.62 s ClockTime = 32 s
Time = 3.0775
Courant Number mean: 0.125217 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000674561, Final residual = 5.71358e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00177351, Final residual = 6.96959e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00338443, Final residual = 0.000201574, No Iterations 4
time step continuity errors : sum local = 4.57423e-08, global = 1.03252e-09, cumulative = 5.86149e-06
GAMG: Solving for p, Initial residual = 0.000822243, Final residual = 9.61961e-07, No Iterations 20
time step continuity errors : sum local = 2.18237e-10, global = -2.35192e-11, cumulative = 5.86146e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00117296, Final residual = 6.23966e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00124865, Final residual = 6.40887e-06, No Iterations 5
ExecutionTime = 31.65 s ClockTime = 32 s
Time = 3.08
Courant Number mean: 0.125112 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000672787, Final residual = 5.73965e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00176979, Final residual = 7.02844e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00325439, Final residual = 0.000197305, No Iterations 4
time step continuity errors : sum local = 4.47649e-08, global = 1.35211e-09, cumulative = 5.86281e-06
GAMG: Solving for p, Initial residual = 0.000809162, Final residual = 7.19039e-07, No Iterations 21
time step continuity errors : sum local = 1.63106e-10, global = -1.68276e-11, cumulative = 5.8628e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116841, Final residual = 6.27724e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00124462, Final residual = 6.44176e-06, No Iterations 5
ExecutionTime = 31.67 s ClockTime = 32 s
Time = 3.0825
Courant Number mean: 0.125008 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000671066, Final residual = 5.76555e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00176592, Final residual = 7.08457e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00326578, Final residual = 0.000193678, No Iterations 4
time step continuity errors : sum local = 4.39075e-08, global = 8.65178e-10, cumulative = 5.86366e-06
GAMG: Solving for p, Initial residual = 0.000812358, Final residual = 8.9078e-07, No Iterations 19
time step continuity errors : sum local = 2.01894e-10, global = -2.04327e-11, cumulative = 5.86364e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00116415, Final residual = 6.31161e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00124072, Final residual = 6.47499e-06, No Iterations 5
ExecutionTime = 31.7 s ClockTime = 32 s
Time = 3.085
Courant Number mean: 0.124903 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000669432, Final residual = 5.79095e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0017619, Final residual = 7.13902e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0032277, Final residual = 0.000187474, No Iterations 4
time step continuity errors : sum local = 4.24729e-08, global = -5.86773e-10, cumulative = 5.86306e-06
GAMG: Solving for p, Initial residual = 0.000804209, Final residual = 7.30131e-07, No Iterations 22
time step continuity errors : sum local = 1.654e-10, global = -1.83482e-11, cumulative = 5.86304e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0011603, Final residual = 6.34698e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00123681, Final residual = 6.50748e-06, No Iterations 5
ExecutionTime = 31.73 s ClockTime = 32 s
Time = 3.0875
Courant Number mean: 0.124799 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000667825, Final residual = 5.81569e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00175778, Final residual = 7.19143e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00329068, Final residual = 0.000186904, No Iterations 4
time step continuity errors : sum local = 4.23209e-08, global = 3.601e-10, cumulative = 5.8634e-06
GAMG: Solving for p, Initial residual = 0.000805848, Final residual = 8.51186e-07, No Iterations 20
time step continuity errors : sum local = 1.92739e-10, global = -2.18427e-11, cumulative = 5.86337e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00115666, Final residual = 6.38265e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00123301, Final residual = 6.54271e-06, No Iterations 5
ExecutionTime = 31.75 s ClockTime = 32 s
Time = 3.09
Courant Number mean: 0.124696 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00066631, Final residual = 5.84014e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00175356, Final residual = 7.24189e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00341991, Final residual = 0.000175148, No Iterations 4
time step continuity errors : sum local = 3.96522e-08, global = -2.97927e-09, cumulative = 5.8604e-06
GAMG: Solving for p, Initial residual = 0.000811688, Final residual = 8.79015e-07, No Iterations 22
time step continuity errors : sum local = 1.99e-10, global = -2.38217e-11, cumulative = 5.86037e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00115316, Final residual = 6.42188e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00122932, Final residual = 6.57647e-06, No Iterations 5
ExecutionTime = 31.78 s ClockTime = 32 s
Time = 3.0925
Courant Number mean: 0.124592 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00066483, Final residual = 5.86389e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00174903, Final residual = 7.2897e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00341875, Final residual = 0.000162553, No Iterations 4
time step continuity errors : sum local = 3.67781e-08, global = -3.49175e-09, cumulative = 5.85688e-06
GAMG: Solving for p, Initial residual = 0.000787955, Final residual = 9.4257e-07, No Iterations 22
time step continuity errors : sum local = 2.13199e-10, global = -2.6972e-11, cumulative = 5.85685e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114969, Final residual = 6.45861e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00122571, Final residual = 6.61414e-06, No Iterations 5
ExecutionTime = 31.8 s ClockTime = 32 s
Time = 3.095
Courant Number mean: 0.124489 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000663327, Final residual = 5.88744e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00174437, Final residual = 7.33644e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00331093, Final residual = 0.000314867, No Iterations 3
time step continuity errors : sum local = 7.12137e-08, global = 7.26831e-09, cumulative = 5.86412e-06
GAMG: Solving for p, Initial residual = 0.000786067, Final residual = 7.67436e-07, No Iterations 21
time step continuity errors : sum local = 1.73524e-10, global = -1.85158e-11, cumulative = 5.8641e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00114619, Final residual = 6.49613e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00122212, Final residual = 6.6516e-06, No Iterations 5
ExecutionTime = 31.83 s ClockTime = 32 s
Time = 3.0975
Courant Number mean: 0.124387 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00066186, Final residual = 5.91434e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00173872, Final residual = 7.37614e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00315467, Final residual = 0.000219245, No Iterations 4
time step continuity errors : sum local = 4.95403e-08, global = -6.53807e-09, cumulative = 5.85756e-06
GAMG: Solving for p, Initial residual = 0.000715318, Final residual = 9.56866e-07, No Iterations 21
time step continuity errors : sum local = 2.1618e-10, global = 5.50032e-11, cumulative = 5.85762e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0011426, Final residual = 6.53235e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00121871, Final residual = 6.69105e-06, No Iterations 5
ExecutionTime = 31.85 s ClockTime = 32 s
Time = 3.1
Courant Number mean: 0.124285 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000660339, Final residual = 5.94137e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00173392, Final residual = 7.42081e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0030057, Final residual = 0.000293865, No Iterations 3
time step continuity errors : sum local = 6.63563e-08, global = 6.81502e-09, cumulative = 5.86443e-06
GAMG: Solving for p, Initial residual = 0.000721841, Final residual = 7.60331e-07, No Iterations 21
time step continuity errors : sum local = 1.71671e-10, global = -1.88381e-11, cumulative = 5.86442e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113897, Final residual = 6.57191e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00121544, Final residual = 6.73163e-06, No Iterations 5
ExecutionTime = 31.91 s ClockTime = 32 s
Time = 3.1025
Courant Number mean: 0.124183 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000658842, Final residual = 5.96789e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0017285, Final residual = 7.46036e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00309427, Final residual = 0.000225169, No Iterations 4
time step continuity errors : sum local = 5.08164e-08, global = -6.92307e-09, cumulative = 5.85749e-06
GAMG: Solving for p, Initial residual = 0.000685427, Final residual = 9.49092e-07, No Iterations 20
time step continuity errors : sum local = 2.14197e-10, global = -2.22092e-11, cumulative = 5.85747e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0011354, Final residual = 6.60942e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00121229, Final residual = 6.77143e-06, No Iterations 5
ExecutionTime = 31.93 s ClockTime = 32 s
Time = 3.105
Courant Number mean: 0.124082 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000657393, Final residual = 5.99722e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00172328, Final residual = 7.50057e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00312092, Final residual = 0.000311149, No Iterations 3
time step continuity errors : sum local = 7.01865e-08, global = 7.46557e-09, cumulative = 5.86494e-06
GAMG: Solving for p, Initial residual = 0.000687613, Final residual = 8.78957e-07, No Iterations 19
time step continuity errors : sum local = 1.98285e-10, global = -1.96317e-11, cumulative = 5.86492e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00113194, Final residual = 6.64739e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00120925, Final residual = 6.81498e-06, No Iterations 5
ExecutionTime = 31.95 s ClockTime = 32 s
Time = 3.1075
Courant Number mean: 0.123982 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00065589, Final residual = 6.02671e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00171721, Final residual = 7.53439e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00324006, Final residual = 0.000227439, No Iterations 4
time step continuity errors : sum local = 5.12711e-08, global = -7.16268e-09, cumulative = 5.85775e-06
GAMG: Solving for p, Initial residual = 0.000686301, Final residual = 9.37645e-07, No Iterations 20
time step continuity errors : sum local = 2.1138e-10, global = -2.26359e-11, cumulative = 5.85773e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112875, Final residual = 6.68939e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00120637, Final residual = 6.85711e-06, No Iterations 5
ExecutionTime = 31.98 s ClockTime = 32 s
Time = 3.11
Courant Number mean: 0.123882 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000654428, Final residual = 6.05622e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00171195, Final residual = 7.57394e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00314899, Final residual = 0.000221437, No Iterations 4
time step continuity errors : sum local = 4.9916e-08, global = -7.12803e-09, cumulative = 5.8506e-06
GAMG: Solving for p, Initial residual = 0.000685524, Final residual = 9.95569e-07, No Iterations 20
time step continuity errors : sum local = 2.2443e-10, global = -2.45967e-11, cumulative = 5.85058e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112575, Final residual = 6.72799e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00120355, Final residual = 6.9023e-06, No Iterations 5
ExecutionTime = 32 s ClockTime = 32 s
Time = 3.1125
Courant Number mean: 0.123783 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000653, Final residual = 6.08864e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00170601, Final residual = 7.60808e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00291311, Final residual = 0.000228284, No Iterations 4
time step continuity errors : sum local = 5.14345e-08, global = -7.37286e-09, cumulative = 5.84321e-06
GAMG: Solving for p, Initial residual = 0.000666235, Final residual = 9.73806e-07, No Iterations 20
time step continuity errors : sum local = 2.19387e-10, global = -2.38647e-11, cumulative = 5.84318e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00112275, Final residual = 6.76673e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00120074, Final residual = 6.94625e-06, No Iterations 5
ExecutionTime = 32.03 s ClockTime = 32 s
Time = 3.115
Courant Number mean: 0.123685 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000651535, Final residual = 6.12531e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00169983, Final residual = 7.64027e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00283886, Final residual = 0.000231921, No Iterations 4
time step continuity errors : sum local = 5.22142e-08, global = -7.58608e-09, cumulative = 5.8356e-06
GAMG: Solving for p, Initial residual = 0.000652005, Final residual = 9.67642e-07, No Iterations 20
time step continuity errors : sum local = 2.17793e-10, global = -2.3788e-11, cumulative = 5.83557e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111977, Final residual = 6.80679e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00119809, Final residual = 6.99162e-06, No Iterations 5
ExecutionTime = 32.06 s ClockTime = 32 s
Time = 3.1175
Courant Number mean: 0.123588 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000650036, Final residual = 6.16382e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0016937, Final residual = 7.67097e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00272581, Final residual = 0.000234252, No Iterations 4
time step continuity errors : sum local = 5.26886e-08, global = -7.73685e-09, cumulative = 5.82784e-06
GAMG: Solving for p, Initial residual = 0.00062538, Final residual = 9.59317e-07, No Iterations 20
time step continuity errors : sum local = 2.15712e-10, global = -2.36593e-11, cumulative = 5.82781e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111687, Final residual = 6.85173e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00119553, Final residual = 7.03715e-06, No Iterations 5
ExecutionTime = 32.08 s ClockTime = 32 s
Time = 3.12
Courant Number mean: 0.123492 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000648548, Final residual = 6.20217e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00168771, Final residual = 7.70021e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00292895, Final residual = 0.000238444, No Iterations 4
time step continuity errors : sum local = 5.35908e-08, global = -7.9844e-09, cumulative = 5.81983e-06
GAMG: Solving for p, Initial residual = 0.000640249, Final residual = 9.38984e-07, No Iterations 20
time step continuity errors : sum local = 2.10974e-10, global = -2.3398e-11, cumulative = 5.8198e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111386, Final residual = 6.89184e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00119305, Final residual = 7.08582e-06, No Iterations 5
ExecutionTime = 32.11 s ClockTime = 32 s
Time = 3.1225
Courant Number mean: 0.123398 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000647043, Final residual = 6.24085e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00168167, Final residual = 7.72837e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00307927, Final residual = 0.000241421, No Iterations 4
time step continuity errors : sum local = 5.42127e-08, global = -8.09926e-09, cumulative = 5.8117e-06
GAMG: Solving for p, Initial residual = 0.00064466, Final residual = 9.4678e-07, No Iterations 20
time step continuity errors : sum local = 2.12535e-10, global = -2.37034e-11, cumulative = 5.81168e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00111085, Final residual = 6.93342e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00119073, Final residual = 7.13576e-06, No Iterations 5
ExecutionTime = 32.14 s ClockTime = 32 s
Time = 3.125
Courant Number mean: 0.123304 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000645665, Final residual = 6.28062e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00167541, Final residual = 7.75554e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0029504, Final residual = 0.000243015, No Iterations 4
time step continuity errors : sum local = 5.45512e-08, global = -8.21642e-09, cumulative = 5.80346e-06
GAMG: Solving for p, Initial residual = 0.000629544, Final residual = 9.36889e-07, No Iterations 20
time step continuity errors : sum local = 2.10253e-10, global = -2.35139e-11, cumulative = 5.80344e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110782, Final residual = 6.97976e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00118862, Final residual = 7.18437e-06, No Iterations 5
ExecutionTime = 32.17 s ClockTime = 32 s
Time = 3.1275
Courant Number mean: 0.123211 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000644294, Final residual = 6.32151e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00166923, Final residual = 7.7817e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00312144, Final residual = 0.000246597, No Iterations 4
time step continuity errors : sum local = 5.53212e-08, global = -8.50754e-09, cumulative = 5.79493e-06
GAMG: Solving for p, Initial residual = 0.000646022, Final residual = 9.16359e-07, No Iterations 20
time step continuity errors : sum local = 2.05554e-10, global = -2.31204e-11, cumulative = 5.79491e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110479, Final residual = 7.02457e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00118656, Final residual = 7.23476e-06, No Iterations 5
ExecutionTime = 32.2 s ClockTime = 32 s
Time = 3.13
Courant Number mean: 0.123119 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000642984, Final residual = 6.365e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00166324, Final residual = 7.80776e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00331483, Final residual = 0.000327839, No Iterations 3
time step continuity errors : sum local = 7.35209e-08, global = 8.26583e-09, cumulative = 5.80318e-06
GAMG: Solving for p, Initial residual = 0.000665574, Final residual = 9.92216e-07, No Iterations 19
time step continuity errors : sum local = 2.22564e-10, global = -2.21125e-11, cumulative = 5.80315e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00110195, Final residual = 7.06915e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00118454, Final residual = 7.28651e-06, No Iterations 5
ExecutionTime = 32.23 s ClockTime = 32 s
Time = 3.1325
Courant Number mean: 0.123028 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000641696, Final residual = 6.41563e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00165654, Final residual = 7.8275e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00267568, Final residual = 0.000243767, No Iterations 4
time step continuity errors : sum local = 5.4636e-08, global = -8.46956e-09, cumulative = 5.79468e-06
GAMG: Solving for p, Initial residual = 0.000578801, Final residual = 8.57152e-07, No Iterations 20
time step continuity errors : sum local = 1.9207e-10, global = -2.1951e-11, cumulative = 5.79466e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010993, Final residual = 7.11894e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0011826, Final residual = 7.33728e-06, No Iterations 5
ExecutionTime = 32.25 s ClockTime = 32 s
Time = 3.135
Courant Number mean: 0.122938 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000640316, Final residual = 6.46555e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00165117, Final residual = 7.85919e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00285615, Final residual = 0.000253187, No Iterations 4
time step continuity errors : sum local = 5.67164e-08, global = -9.10806e-09, cumulative = 5.78555e-06
GAMG: Solving for p, Initial residual = 0.000613867, Final residual = 8.97227e-07, No Iterations 20
time step continuity errors : sum local = 2.00883e-10, global = -2.2881e-11, cumulative = 5.78553e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109694, Final residual = 7.16261e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00118071, Final residual = 7.38886e-06, No Iterations 5
ExecutionTime = 32.28 s ClockTime = 33 s
Time = 3.1375
Courant Number mean: 0.122849 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000638983, Final residual = 6.51631e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00164497, Final residual = 7.8828e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00295342, Final residual = 0.000254361, No Iterations 4
time step continuity errors : sum local = 5.69202e-08, global = -9.20622e-09, cumulative = 5.77633e-06
GAMG: Solving for p, Initial residual = 0.000632176, Final residual = 8.87229e-07, No Iterations 20
time step continuity errors : sum local = 1.98449e-10, global = -2.2778e-11, cumulative = 5.7763e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109451, Final residual = 7.21282e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00117875, Final residual = 7.44166e-06, No Iterations 5
ExecutionTime = 32.3 s ClockTime = 33 s
Time = 3.14
Courant Number mean: 0.12276 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000637716, Final residual = 6.56594e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00163874, Final residual = 7.90832e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00289355, Final residual = 0.00025629, No Iterations 4
time step continuity errors : sum local = 5.73154e-08, global = -9.29476e-09, cumulative = 5.76701e-06
GAMG: Solving for p, Initial residual = 0.000624059, Final residual = 8.99783e-07, No Iterations 20
time step continuity errors : sum local = 2.01136e-10, global = -2.3236e-11, cumulative = 5.76698e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00109204, Final residual = 7.25665e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00117683, Final residual = 7.49438e-06, No Iterations 5
ExecutionTime = 32.33 s ClockTime = 33 s
Time = 3.1425
Courant Number mean: 0.122673 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000636506, Final residual = 6.61523e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00163235, Final residual = 7.93305e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00292226, Final residual = 0.000257187, No Iterations 4
time step continuity errors : sum local = 5.74793e-08, global = -9.3654e-09, cumulative = 5.75762e-06
GAMG: Solving for p, Initial residual = 0.000625283, Final residual = 9.00365e-07, No Iterations 20
time step continuity errors : sum local = 2.01136e-10, global = -2.33547e-11, cumulative = 5.7576e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108952, Final residual = 7.30033e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00117497, Final residual = 7.54807e-06, No Iterations 5
ExecutionTime = 32.36 s ClockTime = 33 s
Time = 3.145
Courant Number mean: 0.122586 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000635263, Final residual = 6.66402e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00162596, Final residual = 7.95807e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00305274, Final residual = 0.00025456, No Iterations 4
time step continuity errors : sum local = 5.68457e-08, global = -9.45802e-09, cumulative = 5.74814e-06
GAMG: Solving for p, Initial residual = 0.000630974, Final residual = 8.92963e-07, No Iterations 20
time step continuity errors : sum local = 1.99326e-10, global = -2.31042e-11, cumulative = 5.74811e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108689, Final residual = 7.35163e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00117312, Final residual = 7.60449e-06, No Iterations 5
ExecutionTime = 32.39 s ClockTime = 33 s
Time = 3.1475
Courant Number mean: 0.122501 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000634023, Final residual = 6.71214e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00162011, Final residual = 7.98364e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00311965, Final residual = 0.000241122, No Iterations 4
time step continuity errors : sum local = 5.38078e-08, global = -8.71062e-09, cumulative = 5.7394e-06
GAMG: Solving for p, Initial residual = 0.000630902, Final residual = 9.60392e-07, No Iterations 21
time step continuity errors : sum local = 2.14211e-10, global = 5.31936e-11, cumulative = 5.73946e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108416, Final residual = 7.39775e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00117134, Final residual = 7.65755e-06, No Iterations 5
ExecutionTime = 32.41 s ClockTime = 33 s
Time = 3.15
Courant Number mean: 0.122416 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000632874, Final residual = 6.759e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00161382, Final residual = 8.01006e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00300547, Final residual = 0.000245767, No Iterations 4
time step continuity errors : sum local = 5.48369e-08, global = -9.21554e-09, cumulative = 5.73024e-06
GAMG: Solving for p, Initial residual = 0.000638787, Final residual = 9.99898e-07, No Iterations 20
time step continuity errors : sum local = 2.22997e-10, global = -2.70765e-11, cumulative = 5.73021e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00108162, Final residual = 7.44357e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00116965, Final residual = 7.71246e-06, No Iterations 5
ExecutionTime = 32.44 s ClockTime = 33 s
Time = 3.1525
Courant Number mean: 0.122332 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000631775, Final residual = 6.80664e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00160777, Final residual = 8.03659e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00286578, Final residual = 0.000245899, No Iterations 4
time step continuity errors : sum local = 5.48338e-08, global = -9.22265e-09, cumulative = 5.72099e-06
GAMG: Solving for p, Initial residual = 0.000615145, Final residual = 9.36244e-07, No Iterations 21
time step continuity errors : sum local = 2.08642e-10, global = 5.17196e-11, cumulative = 5.72104e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010792, Final residual = 7.49372e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00116795, Final residual = 7.76653e-06, No Iterations 5
ExecutionTime = 32.47 s ClockTime = 33 s
Time = 3.155
Courant Number mean: 0.122249 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000630663, Final residual = 6.85389e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00160146, Final residual = 8.06383e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00289294, Final residual = 0.000245175, No Iterations 4
time step continuity errors : sum local = 5.46401e-08, global = -9.37071e-09, cumulative = 5.71167e-06
GAMG: Solving for p, Initial residual = 0.000624748, Final residual = 9.84611e-07, No Iterations 20
time step continuity errors : sum local = 2.19256e-10, global = -2.63754e-11, cumulative = 5.71165e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107712, Final residual = 7.5408e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00116616, Final residual = 7.8223e-06, No Iterations 5
ExecutionTime = 32.5 s ClockTime = 33 s
Time = 3.1575
Courant Number mean: 0.122167 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000629514, Final residual = 6.90131e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00159511, Final residual = 8.09169e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00297547, Final residual = 0.000244429, No Iterations 4
time step continuity errors : sum local = 5.44132e-08, global = -9.31975e-09, cumulative = 5.70233e-06
GAMG: Solving for p, Initial residual = 0.000643448, Final residual = 9.66525e-07, No Iterations 20
time step continuity errors : sum local = 2.14954e-10, global = -2.54198e-11, cumulative = 5.7023e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107508, Final residual = 7.59353e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00116455, Final residual = 7.87866e-06, No Iterations 5
ExecutionTime = 32.52 s ClockTime = 33 s
Time = 3.16
Courant Number mean: 0.122086 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000628347, Final residual = 6.94817e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00158864, Final residual = 8.12078e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00300239, Final residual = 0.00029757, No Iterations 3
time step continuity errors : sum local = 6.61664e-08, global = 7.26525e-09, cumulative = 5.70957e-06
GAMG: Solving for p, Initial residual = 0.000622907, Final residual = 7.41495e-07, No Iterations 21
time step continuity errors : sum local = 1.64791e-10, global = -2.07319e-11, cumulative = 5.70955e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107298, Final residual = 7.64307e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0011629, Final residual = 7.93479e-06, No Iterations 5
ExecutionTime = 32.55 s ClockTime = 33 s
Time = 3.1625
Courant Number mean: 0.122005 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000627201, Final residual = 6.99671e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00158167, Final residual = 8.14221e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00296921, Final residual = 0.000235816, No Iterations 4
time step continuity errors : sum local = 5.24028e-08, global = -8.91165e-09, cumulative = 5.70063e-06
GAMG: Solving for p, Initial residual = 0.000613505, Final residual = 9.52124e-07, No Iterations 20
time step continuity errors : sum local = 2.11493e-10, global = -2.55185e-11, cumulative = 5.70061e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00107093, Final residual = 7.69818e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00116115, Final residual = 7.99198e-06, No Iterations 5
ExecutionTime = 32.58 s ClockTime = 33 s
Time = 3.165
Courant Number mean: 0.121925 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000625897, Final residual = 7.04158e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00157641, Final residual = 8.1812e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00317904, Final residual = 0.000295803, No Iterations 3
time step continuity errors : sum local = 6.57307e-08, global = 7.28163e-09, cumulative = 5.70789e-06
GAMG: Solving for p, Initial residual = 0.000626885, Final residual = 7.5889e-07, No Iterations 21
time step continuity errors : sum local = 1.68581e-10, global = -2.12479e-11, cumulative = 5.70787e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106875, Final residual = 7.7456e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0011594, Final residual = 8.04878e-06, No Iterations 5
ExecutionTime = 32.61 s ClockTime = 33 s
Time = 3.1675
Courant Number mean: 0.121846 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000624682, Final residual = 7.09007e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00156943, Final residual = 8.2022e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00280137, Final residual = 0.000233063, No Iterations 4
time step continuity errors : sum local = 5.1756e-08, global = -8.86765e-09, cumulative = 5.699e-06
GAMG: Solving for p, Initial residual = 0.00060252, Final residual = 9.44571e-07, No Iterations 20
time step continuity errors : sum local = 2.0963e-10, global = -2.5163e-11, cumulative = 5.69898e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106647, Final residual = 7.7952e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00115773, Final residual = 8.1052e-06, No Iterations 5
ExecutionTime = 32.64 s ClockTime = 33 s
Time = 3.17
Courant Number mean: 0.121768 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000623378, Final residual = 7.13377e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0015644, Final residual = 8.24346e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0030038, Final residual = 0.00028076, No Iterations 3
time step continuity errors : sum local = 6.23255e-08, global = 6.83725e-09, cumulative = 5.70581e-06
GAMG: Solving for p, Initial residual = 0.000612728, Final residual = 9.97325e-07, No Iterations 20
time step continuity errors : sum local = 2.21276e-10, global = 5.3186e-11, cumulative = 5.70587e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106414, Final residual = 7.85177e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00115594, Final residual = 8.16406e-06, No Iterations 5
ExecutionTime = 32.66 s ClockTime = 33 s
Time = 3.1725
Courant Number mean: 0.121692 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000622183, Final residual = 7.18188e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0015579, Final residual = 8.26608e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00287869, Final residual = 0.000286847, No Iterations 3
time step continuity errors : sum local = 6.36042e-08, global = 6.79227e-09, cumulative = 5.71266e-06
GAMG: Solving for p, Initial residual = 0.000597529, Final residual = 9.58102e-07, No Iterations 19
time step continuity errors : sum local = 2.12329e-10, global = -2.26476e-11, cumulative = 5.71264e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00106169, Final residual = 7.90113e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00115409, Final residual = 8.22182e-06, No Iterations 5
ExecutionTime = 32.69 s ClockTime = 33 s
Time = 3.175
Courant Number mean: 0.121616 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000620925, Final residual = 7.22748e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00155233, Final residual = 8.30185e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00295933, Final residual = 0.000277875, No Iterations 3
time step continuity errors : sum local = 6.15459e-08, global = 6.57354e-09, cumulative = 5.71921e-06
GAMG: Solving for p, Initial residual = 0.000591067, Final residual = 7.56603e-07, No Iterations 21
time step continuity errors : sum local = 1.67477e-10, global = -2.09482e-11, cumulative = 5.71919e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105934, Final residual = 7.94759e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00115227, Final residual = 8.28067e-06, No Iterations 5
ExecutionTime = 32.71 s ClockTime = 33 s
Time = 3.1775
Courant Number mean: 0.12154 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000619637, Final residual = 7.27218e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00154667, Final residual = 8.334e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00277529, Final residual = 0.000274854, No Iterations 3
time step continuity errors : sum local = 6.08487e-08, global = 6.74784e-09, cumulative = 5.72594e-06
GAMG: Solving for p, Initial residual = 0.000574022, Final residual = 7.30003e-07, No Iterations 21
time step continuity errors : sum local = 1.61548e-10, global = -2.00046e-11, cumulative = 5.72592e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105724, Final residual = 8.00329e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00115047, Final residual = 8.34119e-06, No Iterations 5
ExecutionTime = 32.74 s ClockTime = 33 s
Time = 3.18
Courant Number mean: 0.121466 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000618433, Final residual = 7.31803e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00154125, Final residual = 8.3679e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00301178, Final residual = 0.000275777, No Iterations 3
time step continuity errors : sum local = 6.10282e-08, global = 6.65199e-09, cumulative = 5.73257e-06
GAMG: Solving for p, Initial residual = 0.000592022, Final residual = 7.34957e-07, No Iterations 21
time step continuity errors : sum local = 1.62564e-10, global = -1.998e-11, cumulative = 5.73255e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105521, Final residual = 8.04995e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00114867, Final residual = 8.40187e-06, No Iterations 5
ExecutionTime = 32.77 s ClockTime = 33 s
Time = 3.1825
Courant Number mean: 0.121392 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000617259, Final residual = 7.36292e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00153587, Final residual = 8.40239e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00289114, Final residual = 0.000272852, No Iterations 3
time step continuity errors : sum local = 6.0342e-08, global = 6.70206e-09, cumulative = 5.73925e-06
GAMG: Solving for p, Initial residual = 0.000587188, Final residual = 7.49091e-07, No Iterations 21
time step continuity errors : sum local = 1.65578e-10, global = -2.05144e-11, cumulative = 5.73923e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105306, Final residual = 8.10394e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00114691, Final residual = 8.46138e-06, No Iterations 5
ExecutionTime = 32.8 s ClockTime = 33 s
Time = 3.185
Courant Number mean: 0.12132 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000616045, Final residual = 7.40841e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00153044, Final residual = 8.43762e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00307285, Final residual = 0.000267209, No Iterations 3
time step continuity errors : sum local = 5.90477e-08, global = 6.53697e-09, cumulative = 5.74577e-06
GAMG: Solving for p, Initial residual = 0.000603424, Final residual = 7.45372e-07, No Iterations 21
time step continuity errors : sum local = 1.64619e-10, global = -2.01727e-11, cumulative = 5.74575e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00105094, Final residual = 8.15038e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0011453, Final residual = 8.52158e-06, No Iterations 5
ExecutionTime = 32.83 s ClockTime = 33 s
Time = 3.1875
Courant Number mean: 0.121247 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000614802, Final residual = 7.45346e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00152503, Final residual = 8.47405e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00285134, Final residual = 0.000263829, No Iterations 3
time step continuity errors : sum local = 5.82625e-08, global = 6.63805e-09, cumulative = 5.75239e-06
GAMG: Solving for p, Initial residual = 0.000585318, Final residual = 7.35712e-07, No Iterations 21
time step continuity errors : sum local = 1.62388e-10, global = -1.97859e-11, cumulative = 5.75237e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104873, Final residual = 8.19756e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0011436, Final residual = 8.58195e-06, No Iterations 5
ExecutionTime = 32.86 s ClockTime = 33 s
Time = 3.19
Courant Number mean: 0.121176 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000613635, Final residual = 7.4988e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00151966, Final residual = 8.51021e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00272839, Final residual = 0.000260388, No Iterations 3
time step continuity errors : sum local = 5.74541e-08, global = 6.44837e-09, cumulative = 5.75881e-06
GAMG: Solving for p, Initial residual = 0.00058013, Final residual = 9.92736e-07, No Iterations 20
time step continuity errors : sum local = 2.18917e-10, global = 5.19069e-11, cumulative = 5.75887e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0010463, Final residual = 8.25327e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00114188, Final residual = 8.64297e-06, No Iterations 5
ExecutionTime = 32.88 s ClockTime = 33 s
Time = 3.1925
Courant Number mean: 0.121105 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000612452, Final residual = 7.5437e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00151421, Final residual = 8.54716e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00269587, Final residual = 0.000257733, No Iterations 3
time step continuity errors : sum local = 5.68375e-08, global = 6.51131e-09, cumulative = 5.76538e-06
GAMG: Solving for p, Initial residual = 0.000564972, Final residual = 9.78795e-07, No Iterations 20
time step continuity errors : sum local = 2.15724e-10, global = 5.09271e-11, cumulative = 5.76543e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104386, Final residual = 8.30222e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00114021, Final residual = 8.70347e-06, No Iterations 5
ExecutionTime = 32.91 s ClockTime = 33 s
Time = 3.195
Courant Number mean: 0.121034 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000611295, Final residual = 7.5888e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00150875, Final residual = 8.58354e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00271526, Final residual = 0.000256498, No Iterations 3
time step continuity errors : sum local = 5.65224e-08, global = 6.55721e-09, cumulative = 5.77199e-06
GAMG: Solving for p, Initial residual = 0.000562406, Final residual = 9.80782e-07, No Iterations 20
time step continuity errors : sum local = 2.15998e-10, global = 5.08635e-11, cumulative = 5.77204e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00104146, Final residual = 8.35424e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00113854, Final residual = 8.76708e-06, No Iterations 5
ExecutionTime = 32.94 s ClockTime = 33 s
Time = 3.1975
Courant Number mean: 0.120965 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000610126, Final residual = 7.63349e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0015033, Final residual = 8.62002e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00308947, Final residual = 0.000251702, No Iterations 3
time step continuity errors : sum local = 5.54255e-08, global = 6.22788e-09, cumulative = 5.77826e-06
GAMG: Solving for p, Initial residual = 0.000596098, Final residual = 9.55015e-07, No Iterations 20
time step continuity errors : sum local = 2.10141e-10, global = 4.9361e-11, cumulative = 5.77831e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103923, Final residual = 8.41186e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00113687, Final residual = 8.82991e-06, No Iterations 5
ExecutionTime = 32.97 s ClockTime = 33 s
Time = 3.2
Courant Number mean: 0.120896 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000608867, Final residual = 7.67785e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00149798, Final residual = 8.65714e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00299637, Final residual = 0.000250289, No Iterations 3
time step continuity errors : sum local = 5.50527e-08, global = 6.46098e-09, cumulative = 5.78477e-06
GAMG: Solving for p, Initial residual = 0.000584903, Final residual = 9.71602e-07, No Iterations 20
time step continuity errors : sum local = 2.13534e-10, global = 4.99574e-11, cumulative = 5.78482e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103718, Final residual = 8.45774e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00113516, Final residual = 8.89252e-06, No Iterations 5
ExecutionTime = 33.02 s ClockTime = 33 s
Time = 3.2025
Courant Number mean: 0.120827 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000607537, Final residual = 7.72224e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00149258, Final residual = 8.69345e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00283384, Final residual = 0.00024901, No Iterations 3
time step continuity errors : sum local = 5.47202e-08, global = 6.54944e-09, cumulative = 5.79137e-06
GAMG: Solving for p, Initial residual = 0.000580252, Final residual = 9.75935e-07, No Iterations 20
time step continuity errors : sum local = 2.1432e-10, global = 5.00747e-11, cumulative = 5.79142e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103511, Final residual = 8.5053e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00113353, Final residual = 8.95536e-06, No Iterations 5
ExecutionTime = 33.05 s ClockTime = 33 s
Time = 3.205
Courant Number mean: 0.120759 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000606201, Final residual = 7.76601e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00148715, Final residual = 8.72985e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00279097, Final residual = 0.00024883, No Iterations 3
time step continuity errors : sum local = 5.46406e-08, global = 6.58251e-09, cumulative = 5.79801e-06
GAMG: Solving for p, Initial residual = 0.000588124, Final residual = 9.74149e-07, No Iterations 20
time step continuity errors : sum local = 2.13806e-10, global = 4.98199e-11, cumulative = 5.79806e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103296, Final residual = 8.55323e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00113186, Final residual = 9.01783e-06, No Iterations 5
ExecutionTime = 33.08 s ClockTime = 33 s
Time = 3.2075
Courant Number mean: 0.120692 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000604882, Final residual = 7.80981e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00148152, Final residual = 8.76481e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00263583, Final residual = 0.000246072, No Iterations 3
time step continuity errors : sum local = 5.40116e-08, global = 6.71347e-09, cumulative = 5.80477e-06
GAMG: Solving for p, Initial residual = 0.000565737, Final residual = 9.71075e-07, No Iterations 20
time step continuity errors : sum local = 2.13034e-10, global = 4.95167e-11, cumulative = 5.80482e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00103074, Final residual = 8.59613e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00113007, Final residual = 9.07983e-06, No Iterations 5
ExecutionTime = 33.1 s ClockTime = 33 s
Time = 3.21
Courant Number mean: 0.120626 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000603532, Final residual = 7.85339e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0014761, Final residual = 8.80001e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00273909, Final residual = 0.000242483, No Iterations 3
time step continuity errors : sum local = 5.31773e-08, global = 6.35312e-09, cumulative = 5.81117e-06
GAMG: Solving for p, Initial residual = 0.000568493, Final residual = 9.39982e-07, No Iterations 20
time step continuity errors : sum local = 2.05988e-10, global = 4.76645e-11, cumulative = 5.81122e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102842, Final residual = 8.63988e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00112823, Final residual = 9.14232e-06, No Iterations 5
ExecutionTime = 33.13 s ClockTime = 33 s
Time = 3.2125
Courant Number mean: 0.12056 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000602252, Final residual = 7.89629e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00147068, Final residual = 8.83419e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00295798, Final residual = 0.000241716, No Iterations 3
time step continuity errors : sum local = 5.29697e-08, global = 6.218e-09, cumulative = 5.81744e-06
GAMG: Solving for p, Initial residual = 0.000592728, Final residual = 9.23334e-07, No Iterations 20
time step continuity errors : sum local = 2.0218e-10, global = 4.66527e-11, cumulative = 5.81748e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102596, Final residual = 8.68678e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00112639, Final residual = 9.2053e-06, No Iterations 5
ExecutionTime = 33.15 s ClockTime = 33 s
Time = 3.215
Courant Number mean: 0.120494 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.00060091, Final residual = 7.93885e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00146543, Final residual = 8.86774e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00275024, Final residual = 0.000241361, No Iterations 3
time step continuity errors : sum local = 5.28397e-08, global = 6.1304e-09, cumulative = 5.82361e-06
GAMG: Solving for p, Initial residual = 0.000582934, Final residual = 9.99124e-07, No Iterations 19
time step continuity errors : sum local = 2.18552e-10, global = -2.38375e-11, cumulative = 5.82359e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102338, Final residual = 8.73245e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0011246, Final residual = 9.26664e-06, No Iterations 5
ExecutionTime = 33.18 s ClockTime = 33 s
Time = 3.2175
Courant Number mean: 0.120429 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000599486, Final residual = 7.98128e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00145999, Final residual = 8.90008e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00275355, Final residual = 0.000240676, No Iterations 3
time step continuity errors : sum local = 5.26562e-08, global = 6.3113e-09, cumulative = 5.8299e-06
GAMG: Solving for p, Initial residual = 0.000581331, Final residual = 9.10629e-07, No Iterations 20
time step continuity errors : sum local = 1.99118e-10, global = 4.58918e-11, cumulative = 5.82995e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00102092, Final residual = 8.77822e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00112268, Final residual = 9.33133e-06, No Iterations 5
ExecutionTime = 33.21 s ClockTime = 33 s
Time = 3.22
Courant Number mean: 0.120365 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.00059798, Final residual = 8.02317e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00145485, Final residual = 8.93142e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00261964, Final residual = 0.000236832, No Iterations 3
time step continuity errors : sum local = 5.1775e-08, global = 6.2032e-09, cumulative = 5.83615e-06
GAMG: Solving for p, Initial residual = 0.000565498, Final residual = 8.93988e-07, No Iterations 20
time step continuity errors : sum local = 1.95277e-10, global = 4.47192e-11, cumulative = 5.8362e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101859, Final residual = 8.82152e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00112074, Final residual = 9.39481e-06, No Iterations 5
ExecutionTime = 33.23 s ClockTime = 33 s
Time = 3.2225
Courant Number mean: 0.120301 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000596489, Final residual = 8.06449e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00144958, Final residual = 8.96153e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00265346, Final residual = 0.000237563, No Iterations 3
time step continuity errors : sum local = 5.18991e-08, global = 6.27986e-09, cumulative = 5.84248e-06
GAMG: Solving for p, Initial residual = 0.000558402, Final residual = 9.92788e-07, No Iterations 19
time step continuity errors : sum local = 2.16741e-10, global = -2.31916e-11, cumulative = 5.84245e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101633, Final residual = 8.86762e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00111878, Final residual = 9.45893e-06, No Iterations 5
ExecutionTime = 33.25 s ClockTime = 33 s
Time = 3.225
Courant Number mean: 0.120238 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000594951, Final residual = 8.10543e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00144415, Final residual = 8.99055e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00267876, Final residual = 0.000234952, No Iterations 3
time step continuity errors : sum local = 5.12902e-08, global = 6.21951e-09, cumulative = 5.84867e-06
GAMG: Solving for p, Initial residual = 0.000569748, Final residual = 8.98765e-07, No Iterations 20
time step continuity errors : sum local = 1.96041e-10, global = 4.49914e-11, cumulative = 5.84872e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101408, Final residual = 8.91415e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00111679, Final residual = 9.52337e-06, No Iterations 5
ExecutionTime = 33.28 s ClockTime = 34 s
Time = 3.2275
Courant Number mean: 0.120176 max: 0.616695
smoothSolver: Solving for Ux, Initial residual = 0.000593419, Final residual = 8.14587e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0014389, Final residual = 9.01929e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00293838, Final residual = 0.000236878, No Iterations 3
time step continuity errors : sum local = 5.1674e-08, global = 6.39648e-09, cumulative = 5.85511e-06
GAMG: Solving for p, Initial residual = 0.000588039, Final residual = 9.92387e-07, No Iterations 19
time step continuity errors : sum local = 2.16329e-10, global = -2.32638e-11, cumulative = 5.85509e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00101155, Final residual = 8.96168e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0011147, Final residual = 9.5869e-06, No Iterations 5
ExecutionTime = 33.31 s ClockTime = 34 s
Time = 3.23
Courant Number mean: 0.120114 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000591908, Final residual = 8.18606e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00143358, Final residual = 9.04678e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00271491, Final residual = 0.000232152, No Iterations 3
time step continuity errors : sum local = 5.06005e-08, global = 6.04388e-09, cumulative = 5.86113e-06
GAMG: Solving for p, Initial residual = 0.000572106, Final residual = 9.62016e-07, No Iterations 19
time step continuity errors : sum local = 2.09509e-10, global = -2.19783e-11, cumulative = 5.86111e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100894, Final residual = 9.01029e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00111264, Final residual = 9.6509e-06, No Iterations 5
ExecutionTime = 33.34 s ClockTime = 34 s
Time = 3.2325
Courant Number mean: 0.120052 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000590356, Final residual = 8.22508e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00142804, Final residual = 9.07369e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00286251, Final residual = 0.000231053, No Iterations 3
time step continuity errors : sum local = 5.03167e-08, global = 5.73256e-09, cumulative = 5.86684e-06
GAMG: Solving for p, Initial residual = 0.000595545, Final residual = 9.3592e-07, No Iterations 19
time step continuity errors : sum local = 2.03643e-10, global = -2.08618e-11, cumulative = 5.86682e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100628, Final residual = 9.05566e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0011106, Final residual = 9.71677e-06, No Iterations 5
ExecutionTime = 33.36 s ClockTime = 34 s
Time = 3.235
Courant Number mean: 0.119991 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00058875, Final residual = 8.26362e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00142238, Final residual = 9.10022e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00258398, Final residual = 0.000231203, No Iterations 3
time step continuity errors : sum local = 5.03156e-08, global = 5.80811e-09, cumulative = 5.87263e-06
GAMG: Solving for p, Initial residual = 0.000568959, Final residual = 9.23176e-07, No Iterations 19
time step continuity errors : sum local = 2.00752e-10, global = -2.04307e-11, cumulative = 5.87261e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100367, Final residual = 9.09783e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00110846, Final residual = 9.78424e-06, No Iterations 5
ExecutionTime = 33.39 s ClockTime = 34 s
Time = 3.2375
Courant Number mean: 0.119931 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000587196, Final residual = 8.30203e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00141684, Final residual = 9.1243e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00261595, Final residual = 0.000229923, No Iterations 3
time step continuity errors : sum local = 5.00105e-08, global = 5.94165e-09, cumulative = 5.87855e-06
GAMG: Solving for p, Initial residual = 0.000565759, Final residual = 9.29064e-07, No Iterations 19
time step continuity errors : sum local = 2.01917e-10, global = -2.05719e-11, cumulative = 5.87853e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00100104, Final residual = 9.14403e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00110632, Final residual = 9.85148e-06, No Iterations 5
ExecutionTime = 33.42 s ClockTime = 34 s
Time = 3.24
Courant Number mean: 0.119871 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000585597, Final residual = 8.3396e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00141146, Final residual = 9.14882e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00255719, Final residual = 0.000228018, No Iterations 3
time step continuity errors : sum local = 4.95632e-08, global = 5.86846e-09, cumulative = 5.8844e-06
GAMG: Solving for p, Initial residual = 0.00057416, Final residual = 9.09141e-07, No Iterations 19
time step continuity errors : sum local = 1.97446e-10, global = -1.99633e-11, cumulative = 5.88438e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000998605, Final residual = 9.19097e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0011041, Final residual = 9.91775e-06, No Iterations 5
ExecutionTime = 33.44 s ClockTime = 34 s
Time = 3.2425
Courant Number mean: 0.119812 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000583949, Final residual = 8.3764e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0014059, Final residual = 9.17224e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00267982, Final residual = 0.00022651, No Iterations 3
time step continuity errors : sum local = 4.91972e-08, global = 5.66052e-09, cumulative = 5.89004e-06
GAMG: Solving for p, Initial residual = 0.000585642, Final residual = 8.8564e-07, No Iterations 19
time step continuity errors : sum local = 1.9218e-10, global = -1.91595e-11, cumulative = 5.89002e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000996282, Final residual = 9.23965e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00110189, Final residual = 9.9867e-06, No Iterations 5
ExecutionTime = 33.47 s ClockTime = 34 s
Time = 3.245
Courant Number mean: 0.119753 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000582254, Final residual = 8.41263e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00140023, Final residual = 9.19546e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00281381, Final residual = 0.000227469, No Iterations 3
time step continuity errors : sum local = 4.93696e-08, global = 5.65333e-09, cumulative = 5.89568e-06
GAMG: Solving for p, Initial residual = 0.000588224, Final residual = 8.75266e-07, No Iterations 19
time step continuity errors : sum local = 1.89791e-10, global = -1.88328e-11, cumulative = 5.89566e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000993967, Final residual = 9.28843e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0010996, Final residual = 4.50052e-06, No Iterations 6
ExecutionTime = 33.49 s ClockTime = 34 s
Time = 3.2475
Courant Number mean: 0.119695 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000580533, Final residual = 8.44987e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00139441, Final residual = 9.2189e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00279217, Final residual = 0.0002288, No Iterations 3
time step continuity errors : sum local = 4.9617e-08, global = 5.92266e-09, cumulative = 5.90158e-06
GAMG: Solving for p, Initial residual = 0.000581078, Final residual = 8.70984e-07, No Iterations 19
time step continuity errors : sum local = 1.88712e-10, global = -1.89429e-11, cumulative = 5.90156e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00099148, Final residual = 9.34076e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00109738, Final residual = 4.53946e-06, No Iterations 6
ExecutionTime = 33.53 s ClockTime = 34 s
Time = 3.25
Courant Number mean: 0.119638 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000578783, Final residual = 8.48644e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00138845, Final residual = 9.24091e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00255654, Final residual = 0.000230324, No Iterations 3
time step continuity errors : sum local = 4.99108e-08, global = 5.90713e-09, cumulative = 5.90747e-06
GAMG: Solving for p, Initial residual = 0.000563345, Final residual = 8.69987e-07, No Iterations 19
time step continuity errors : sum local = 1.88366e-10, global = -1.8956e-11, cumulative = 5.90745e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000988942, Final residual = 9.39165e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00109509, Final residual = 4.58011e-06, No Iterations 6
ExecutionTime = 33.55 s ClockTime = 34 s
Time = 3.2525
Courant Number mean: 0.119581 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000577061, Final residual = 8.52201e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00138253, Final residual = 9.26341e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00265426, Final residual = 0.000229255, No Iterations 3
time step continuity errors : sum local = 4.96511e-08, global = 5.94527e-09, cumulative = 5.91339e-06
GAMG: Solving for p, Initial residual = 0.00057346, Final residual = 8.57898e-07, No Iterations 19
time step continuity errors : sum local = 1.85628e-10, global = -1.84997e-11, cumulative = 5.91338e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000986411, Final residual = 9.44108e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00109269, Final residual = 4.61999e-06, No Iterations 6
ExecutionTime = 33.58 s ClockTime = 34 s
Time = 3.255
Courant Number mean: 0.119524 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000575331, Final residual = 8.55722e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00137657, Final residual = 9.28528e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00261266, Final residual = 0.000231072, No Iterations 3
time step continuity errors : sum local = 5.00055e-08, global = 5.81054e-09, cumulative = 5.91919e-06
GAMG: Solving for p, Initial residual = 0.000577549, Final residual = 8.39169e-07, No Iterations 19
time step continuity errors : sum local = 1.81436e-10, global = -1.78714e-11, cumulative = 5.91917e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000983795, Final residual = 9.49051e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00109027, Final residual = 4.66143e-06, No Iterations 6
ExecutionTime = 33.61 s ClockTime = 34 s
Time = 3.2575
Courant Number mean: 0.119468 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00057359, Final residual = 8.59137e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00137085, Final residual = 9.30622e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0026852, Final residual = 0.000232862, No Iterations 3
time step continuity errors : sum local = 5.0354e-08, global = 5.72322e-09, cumulative = 5.92489e-06
GAMG: Solving for p, Initial residual = 0.000592174, Final residual = 8.10879e-07, No Iterations 19
time step continuity errors : sum local = 1.75165e-10, global = -1.71163e-11, cumulative = 5.92487e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000981285, Final residual = 9.54304e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00108777, Final residual = 4.7037e-06, No Iterations 6
ExecutionTime = 33.63 s ClockTime = 34 s
Time = 3.26
Courant Number mean: 0.119413 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000571783, Final residual = 8.62551e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00136493, Final residual = 9.3263e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00273943, Final residual = 0.000233408, No Iterations 3
time step continuity errors : sum local = 5.04302e-08, global = 5.56369e-09, cumulative = 5.93044e-06
GAMG: Solving for p, Initial residual = 0.000599245, Final residual = 8.00584e-07, No Iterations 19
time step continuity errors : sum local = 1.72815e-10, global = -1.66963e-11, cumulative = 5.93042e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000978734, Final residual = 9.59789e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00108531, Final residual = 4.74757e-06, No Iterations 6
ExecutionTime = 33.66 s ClockTime = 34 s
Time = 3.2625
Courant Number mean: 0.119358 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000569905, Final residual = 8.65868e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00135887, Final residual = 9.34613e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00274285, Final residual = 0.000233178, No Iterations 3
time step continuity errors : sum local = 5.03611e-08, global = 5.4891e-09, cumulative = 5.93591e-06
GAMG: Solving for p, Initial residual = 0.000609071, Final residual = 7.82159e-07, No Iterations 19
time step continuity errors : sum local = 1.68787e-10, global = -1.60532e-11, cumulative = 5.93589e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000976237, Final residual = 9.65386e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00108285, Final residual = 4.79088e-06, No Iterations 6
ExecutionTime = 33.69 s ClockTime = 34 s
Time = 3.265
Courant Number mean: 0.119304 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000567985, Final residual = 8.69096e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0013528, Final residual = 9.36624e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00237221, Final residual = 0.000120003, No Iterations 5
time step continuity errors : sum local = 2.59049e-08, global = 2.23388e-09, cumulative = 5.93813e-06
GAMG: Solving for p, Initial residual = 0.000625713, Final residual = 8.94948e-07, No Iterations 19
time step continuity errors : sum local = 1.92905e-10, global = -1.09922e-11, cumulative = 5.93812e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00097363, Final residual = 9.70495e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0010803, Final residual = 4.83504e-06, No Iterations 6
ExecutionTime = 33.71 s ClockTime = 34 s
Time = 3.2675
Courant Number mean: 0.11925 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000566015, Final residual = 8.7158e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00134775, Final residual = 9.39983e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00261971, Final residual = 0.000140662, No Iterations 5
time step continuity errors : sum local = 3.03529e-08, global = 2.57735e-09, cumulative = 5.94069e-06
GAMG: Solving for p, Initial residual = 0.000686632, Final residual = 9.3823e-07, No Iterations 19
time step continuity errors : sum local = 2.02088e-10, global = -1.12036e-11, cumulative = 5.94068e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00097106, Final residual = 9.75958e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00107764, Final residual = 4.87926e-06, No Iterations 6
ExecutionTime = 33.74 s ClockTime = 34 s
Time = 3.27
Courant Number mean: 0.119197 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000564137, Final residual = 8.74877e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00134159, Final residual = 9.41533e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00268525, Final residual = 0.00013648, No Iterations 5
time step continuity errors : sum local = 2.94247e-08, global = 2.3721e-09, cumulative = 5.94306e-06
GAMG: Solving for p, Initial residual = 0.000687519, Final residual = 9.58175e-07, No Iterations 19
time step continuity errors : sum local = 2.06188e-10, global = -1.11136e-11, cumulative = 5.94304e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000968246, Final residual = 9.81396e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00107501, Final residual = 4.92339e-06, No Iterations 6
ExecutionTime = 33.77 s ClockTime = 34 s
Time = 3.2725
Courant Number mean: 0.119144 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000562175, Final residual = 8.77854e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0013357, Final residual = 9.43536e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00273935, Final residual = 0.000139734, No Iterations 5
time step continuity errors : sum local = 3.01105e-08, global = 2.4558e-09, cumulative = 5.9455e-06
GAMG: Solving for p, Initial residual = 0.000703736, Final residual = 9.58214e-07, No Iterations 19
time step continuity errors : sum local = 2.06089e-10, global = -1.10112e-11, cumulative = 5.94549e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000965618, Final residual = 9.87128e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00107239, Final residual = 4.9689e-06, No Iterations 6
ExecutionTime = 33.79 s ClockTime = 34 s
Time = 3.275
Courant Number mean: 0.119092 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000560248, Final residual = 8.80925e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00132975, Final residual = 9.45287e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00279179, Final residual = 0.000276078, No Iterations 3
time step continuity errors : sum local = 5.94477e-08, global = 6.94222e-09, cumulative = 5.95243e-06
GAMG: Solving for p, Initial residual = 0.00062324, Final residual = 7.59735e-07, No Iterations 19
time step continuity errors : sum local = 1.63423e-10, global = -1.61579e-11, cumulative = 5.95242e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000962894, Final residual = 9.92906e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00106979, Final residual = 5.01605e-06, No Iterations 6
ExecutionTime = 33.82 s ClockTime = 34 s
Time = 3.2775
Courant Number mean: 0.11904 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000558375, Final residual = 8.84946e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00132237, Final residual = 9.44797e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00290926, Final residual = 0.000229365, No Iterations 3
time step continuity errors : sum local = 4.9337e-08, global = 5.45808e-09, cumulative = 5.95787e-06
GAMG: Solving for p, Initial residual = 0.000604816, Final residual = 7.22199e-07, No Iterations 19
time step continuity errors : sum local = 1.55198e-10, global = -1.40755e-11, cumulative = 5.95786e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000960252, Final residual = 9.98241e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0010673, Final residual = 5.06423e-06, No Iterations 6
ExecutionTime = 33.85 s ClockTime = 34 s
Time = 3.28
Courant Number mean: 0.118989 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000556239, Final residual = 8.87312e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00131706, Final residual = 9.47912e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0025931, Final residual = 0.000251537, No Iterations 3
time step continuity errors : sum local = 5.4085e-08, global = 6.24103e-09, cumulative = 5.9641e-06
GAMG: Solving for p, Initial residual = 0.000588533, Final residual = 7.25566e-07, No Iterations 19
time step continuity errors : sum local = 1.55868e-10, global = -1.50674e-11, cumulative = 5.96409e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000957582, Final residual = 3.94768e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00106481, Final residual = 5.11187e-06, No Iterations 6
ExecutionTime = 33.87 s ClockTime = 34 s
Time = 3.2825
Courant Number mean: 0.118938 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000554245, Final residual = 8.90339e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00131057, Final residual = 9.48881e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00258669, Final residual = 0.000240843, No Iterations 3
time step continuity errors : sum local = 5.17523e-08, global = 5.67746e-09, cumulative = 5.96976e-06
GAMG: Solving for p, Initial residual = 0.000586878, Final residual = 6.98971e-07, No Iterations 19
time step continuity errors : sum local = 1.50056e-10, global = -1.35766e-11, cumulative = 5.96975e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000954827, Final residual = 3.97658e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00106213, Final residual = 5.15766e-06, No Iterations 6
ExecutionTime = 33.9 s ClockTime = 34 s
Time = 3.285
Courant Number mean: 0.118887 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000552195, Final residual = 8.92861e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00130492, Final residual = 9.51175e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00244806, Final residual = 0.00012454, No Iterations 5
time step continuity errors : sum local = 2.67481e-08, global = 2.07784e-09, cumulative = 5.97183e-06
GAMG: Solving for p, Initial residual = 0.000648489, Final residual = 9.10755e-07, No Iterations 19
time step continuity errors : sum local = 1.95268e-10, global = -9.62303e-12, cumulative = 5.97182e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000952196, Final residual = 4.0051e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00105928, Final residual = 5.20218e-06, No Iterations 6
ExecutionTime = 33.93 s ClockTime = 34 s
Time = 3.2875
Courant Number mean: 0.118838 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000550035, Final residual = 8.946e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00129993, Final residual = 9.54512e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00256332, Final residual = 0.000148501, No Iterations 5
time step continuity errors : sum local = 3.18843e-08, global = 2.51504e-09, cumulative = 5.97433e-06
GAMG: Solving for p, Initial residual = 0.00071015, Final residual = 9.79208e-07, No Iterations 19
time step continuity errors : sum local = 2.09827e-10, global = -1.03552e-11, cumulative = 5.97432e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000949402, Final residual = 4.03837e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00105643, Final residual = 5.24801e-06, No Iterations 6
ExecutionTime = 33.95 s ClockTime = 34 s
Time = 3.29
Courant Number mean: 0.118788 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000547961, Final residual = 8.97406e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00129365, Final residual = 9.55955e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00266142, Final residual = 0.000143314, No Iterations 5
time step continuity errors : sum local = 3.07447e-08, global = 2.36354e-09, cumulative = 5.97669e-06
GAMG: Solving for p, Initial residual = 0.000714788, Final residual = 9.88177e-07, No Iterations 19
time step continuity errors : sum local = 2.11541e-10, global = -1.02442e-11, cumulative = 5.97668e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000946525, Final residual = 4.06829e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00105359, Final residual = 5.29462e-06, No Iterations 6
ExecutionTime = 33.98 s ClockTime = 34 s
Time = 3.2925
Courant Number mean: 0.118739 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000545802, Final residual = 8.99862e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0012879, Final residual = 9.57802e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0030119, Final residual = 0.00028683, No Iterations 3
time step continuity errors : sum local = 6.14782e-08, global = 7.09982e-09, cumulative = 5.98378e-06
GAMG: Solving for p, Initial residual = 0.000653433, Final residual = 6.86566e-07, No Iterations 19
time step continuity errors : sum local = 1.46962e-10, global = -1.41661e-11, cumulative = 5.98376e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000943823, Final residual = 4.09882e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00105074, Final residual = 5.34258e-06, No Iterations 6
ExecutionTime = 34.01 s ClockTime = 34 s
Time = 3.295
Courant Number mean: 0.11869 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000543733, Final residual = 9.03663e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00128035, Final residual = 9.56785e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00265814, Final residual = 0.000232584, No Iterations 3
time step continuity errors : sum local = 4.97902e-08, global = 5.0054e-09, cumulative = 5.98877e-06
GAMG: Solving for p, Initial residual = 0.000593016, Final residual = 6.9198e-07, No Iterations 19
time step continuity errors : sum local = 1.47964e-10, global = -1.08875e-11, cumulative = 5.98876e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000941055, Final residual = 4.12776e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00104803, Final residual = 5.39039e-06, No Iterations 6
ExecutionTime = 34.03 s ClockTime = 34 s
Time = 3.2975
Courant Number mean: 0.118642 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000541431, Final residual = 9.05345e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0012753, Final residual = 9.60264e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0025561, Final residual = 0.000132565, No Iterations 5
time step continuity errors : sum local = 2.83624e-08, global = 2.15154e-09, cumulative = 5.99091e-06
GAMG: Solving for p, Initial residual = 0.000674077, Final residual = 9.38867e-07, No Iterations 19
time step continuity errors : sum local = 2.00489e-10, global = -9.38808e-12, cumulative = 5.9909e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000938059, Final residual = 4.16183e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00104527, Final residual = 5.43696e-06, No Iterations 6
ExecutionTime = 34.06 s ClockTime = 34 s
Time = 3.3
Courant Number mean: 0.118594 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000539245, Final residual = 9.07045e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00127014, Final residual = 9.63363e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00261433, Final residual = 0.000153103, No Iterations 5
time step continuity errors : sum local = 3.27381e-08, global = 2.58927e-09, cumulative = 5.99349e-06
GAMG: Solving for p, Initial residual = 0.000728618, Final residual = 9.9222e-07, No Iterations 19
time step continuity errors : sum local = 2.11705e-10, global = -9.99616e-12, cumulative = 5.99348e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000935288, Final residual = 4.19427e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00104238, Final residual = 5.48554e-06, No Iterations 6
ExecutionTime = 34.11 s ClockTime = 34 s
Time = 3.3025
Courant Number mean: 0.118547 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000537134, Final residual = 9.096e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0012638, Final residual = 9.65016e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00257325, Final residual = 0.000150094, No Iterations 5
time step continuity errors : sum local = 3.20727e-08, global = 2.49739e-09, cumulative = 5.99597e-06
GAMG: Solving for p, Initial residual = 0.000723385, Final residual = 9.97538e-07, No Iterations 19
time step continuity errors : sum local = 2.12725e-10, global = -9.94615e-12, cumulative = 5.99596e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000932627, Final residual = 4.22692e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00103945, Final residual = 5.53626e-06, No Iterations 6
ExecutionTime = 34.14 s ClockTime = 34 s
Time = 3.305
Courant Number mean: 0.1185 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000534965, Final residual = 9.11837e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00125772, Final residual = 9.66976e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00250036, Final residual = 0.000149831, No Iterations 5
time step continuity errors : sum local = 3.19942e-08, global = 2.38987e-09, cumulative = 5.99835e-06
GAMG: Solving for p, Initial residual = 0.000719355, Final residual = 5.62521e-07, No Iterations 21
time step continuity errors : sum local = 1.19859e-10, global = -5.71697e-12, cumulative = 5.99835e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000929875, Final residual = 4.25961e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00103644, Final residual = 5.58659e-06, No Iterations 6
ExecutionTime = 34.16 s ClockTime = 34 s
Time = 3.3075
Courant Number mean: 0.118453 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000532788, Final residual = 9.14073e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00125157, Final residual = 9.68929e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00268727, Final residual = 0.000149665, No Iterations 5
time step continuity errors : sum local = 3.19328e-08, global = 2.3236e-09, cumulative = 6.00067e-06
GAMG: Solving for p, Initial residual = 0.000744342, Final residual = 5.70773e-07, No Iterations 21
time step continuity errors : sum local = 1.21506e-10, global = -5.75696e-12, cumulative = 6.00067e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000927013, Final residual = 4.29474e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00103347, Final residual = 5.63627e-06, No Iterations 6
ExecutionTime = 34.19 s ClockTime = 34 s
Time = 3.31
Courant Number mean: 0.118407 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000530484, Final residual = 9.16256e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00124563, Final residual = 9.70943e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00287158, Final residual = 0.000284767, No Iterations 3
time step continuity errors : sum local = 6.06983e-08, global = 7.06716e-09, cumulative = 6.00773e-06
GAMG: Solving for p, Initial residual = 0.000660398, Final residual = 6.66113e-07, No Iterations 19
time step continuity errors : sum local = 1.41773e-10, global = -1.20646e-11, cumulative = 6.00772e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000924106, Final residual = 4.33062e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00103059, Final residual = 5.6859e-06, No Iterations 6
ExecutionTime = 34.22 s ClockTime = 34 s
Time = 3.3125
Courant Number mean: 0.118361 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000528273, Final residual = 9.19964e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00123806, Final residual = 9.70082e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00259558, Final residual = 0.000232901, No Iterations 3
time step continuity errors : sum local = 4.95796e-08, global = 5.13773e-09, cumulative = 6.01286e-06
GAMG: Solving for p, Initial residual = 0.000598139, Final residual = 6.7628e-07, No Iterations 19
time step continuity errors : sum local = 1.43794e-10, global = -9.5505e-12, cumulative = 6.01285e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000921411, Final residual = 4.36319e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00102782, Final residual = 5.73751e-06, No Iterations 6
ExecutionTime = 34.24 s ClockTime = 34 s
Time = 3.315
Courant Number mean: 0.118315 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000525869, Final residual = 9.21286e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00123293, Final residual = 9.73981e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00234878, Final residual = 0.000138235, No Iterations 5
time step continuity errors : sum local = 2.94063e-08, global = 2.23095e-09, cumulative = 6.01508e-06
GAMG: Solving for p, Initial residual = 0.00067478, Final residual = 9.60308e-07, No Iterations 19
time step continuity errors : sum local = 2.0385e-10, global = -9.15993e-12, cumulative = 6.01507e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00091858, Final residual = 4.40032e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00102502, Final residual = 5.79003e-06, No Iterations 6
ExecutionTime = 34.26 s ClockTime = 35 s
Time = 3.3175
Courant Number mean: 0.11827 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000523563, Final residual = 9.22591e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00122759, Final residual = 9.77429e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00244687, Final residual = 0.000159844, No Iterations 5
time step continuity errors : sum local = 3.39806e-08, global = 2.67187e-09, cumulative = 6.01774e-06
GAMG: Solving for p, Initial residual = 0.000731835, Final residual = 5.66009e-07, No Iterations 21
time step continuity errors : sum local = 1.20053e-10, global = -5.66751e-12, cumulative = 6.01774e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00091585, Final residual = 4.43308e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00102216, Final residual = 5.84402e-06, No Iterations 6
ExecutionTime = 34.29 s ClockTime = 35 s
Time = 3.32
Courant Number mean: 0.118225 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000521363, Final residual = 9.24863e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00122132, Final residual = 9.793e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00250926, Final residual = 0.000157111, No Iterations 5
time step continuity errors : sum local = 3.33743e-08, global = 2.61527e-09, cumulative = 6.02035e-06
GAMG: Solving for p, Initial residual = 0.00073715, Final residual = 5.67361e-07, No Iterations 21
time step continuity errors : sum local = 1.20258e-10, global = -5.67958e-12, cumulative = 6.02035e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000913235, Final residual = 4.46983e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0010192, Final residual = 5.89576e-06, No Iterations 6
ExecutionTime = 34.32 s ClockTime = 35 s
Time = 3.3225
Courant Number mean: 0.11818 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000519102, Final residual = 9.26825e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00121522, Final residual = 9.81457e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00271837, Final residual = 0.000156325, No Iterations 5
time step continuity errors : sum local = 3.3181e-08, global = 2.49705e-09, cumulative = 6.02284e-06
GAMG: Solving for p, Initial residual = 0.000761147, Final residual = 5.75556e-07, No Iterations 21
time step continuity errors : sum local = 1.21884e-10, global = -5.72358e-12, cumulative = 6.02284e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000910526, Final residual = 4.50491e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00101617, Final residual = 5.94581e-06, No Iterations 6
ExecutionTime = 34.34 s ClockTime = 35 s
Time = 3.325
Courant Number mean: 0.118136 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000516749, Final residual = 9.28744e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00120918, Final residual = 9.83731e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00271505, Final residual = 0.000158436, No Iterations 5
time step continuity errors : sum local = 3.35983e-08, global = 2.565e-09, cumulative = 6.0254e-06
GAMG: Solving for p, Initial residual = 0.000765229, Final residual = 5.76549e-07, No Iterations 21
time step continuity errors : sum local = 1.21981e-10, global = -5.72857e-12, cumulative = 6.0254e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000907677, Final residual = 4.54062e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00101315, Final residual = 5.99884e-06, No Iterations 6
ExecutionTime = 34.37 s ClockTime = 35 s
Time = 3.3275
Courant Number mean: 0.118092 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000514339, Final residual = 9.30671e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00120306, Final residual = 9.85875e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00247256, Final residual = 0.000160128, No Iterations 5
time step continuity errors : sum local = 3.39292e-08, global = 2.6421e-09, cumulative = 6.02804e-06
GAMG: Solving for p, Initial residual = 0.000749527, Final residual = 5.74588e-07, No Iterations 21
time step continuity errors : sum local = 1.21479e-10, global = -5.7074e-12, cumulative = 6.02803e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000904783, Final residual = 4.5763e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.0010103, Final residual = 6.05133e-06, No Iterations 6
ExecutionTime = 34.4 s ClockTime = 35 s
Time = 3.33
Courant Number mean: 0.118049 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00051197, Final residual = 9.32594e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00119707, Final residual = 9.88023e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00236773, Final residual = 0.000161296, No Iterations 5
time step continuity errors : sum local = 3.4151e-08, global = 2.70201e-09, cumulative = 6.03074e-06
GAMG: Solving for p, Initial residual = 0.000741666, Final residual = 5.72191e-07, No Iterations 21
time step continuity errors : sum local = 1.20888e-10, global = -5.67664e-12, cumulative = 6.03073e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000901931, Final residual = 4.61282e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00100736, Final residual = 6.10481e-06, No Iterations 6
ExecutionTime = 34.43 s ClockTime = 35 s
Time = 3.3325
Courant Number mean: 0.118006 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000509593, Final residual = 9.34486e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.001191, Final residual = 9.9024e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00258132, Final residual = 0.000162038, No Iterations 5
time step continuity errors : sum local = 3.42832e-08, global = 2.67765e-09, cumulative = 6.03341e-06
GAMG: Solving for p, Initial residual = 0.000755606, Final residual = 5.75223e-07, No Iterations 21
time step continuity errors : sum local = 1.21439e-10, global = -5.70528e-12, cumulative = 6.0334e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000899334, Final residual = 4.64944e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00100445, Final residual = 6.15633e-06, No Iterations 6
ExecutionTime = 34.46 s ClockTime = 35 s
Time = 3.335
Courant Number mean: 0.117963 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000507223, Final residual = 9.36313e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00118512, Final residual = 9.92529e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0024752, Final residual = 0.000164029, No Iterations 5
time step continuity errors : sum local = 3.46839e-08, global = 2.71539e-09, cumulative = 6.03612e-06
GAMG: Solving for p, Initial residual = 0.000744767, Final residual = 5.76189e-07, No Iterations 21
time step continuity errors : sum local = 1.21556e-10, global = -5.70279e-12, cumulative = 6.03611e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000896594, Final residual = 4.68495e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00100147, Final residual = 6.21124e-06, No Iterations 6
ExecutionTime = 34.5 s ClockTime = 35 s
Time = 3.3375
Courant Number mean: 0.11792 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000504961, Final residual = 9.38147e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00117915, Final residual = 9.9484e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0027464, Final residual = 0.00016453, No Iterations 5
time step continuity errors : sum local = 3.47606e-08, global = 2.66618e-09, cumulative = 6.03878e-06
GAMG: Solving for p, Initial residual = 0.000766404, Final residual = 5.81556e-07, No Iterations 21
time step continuity errors : sum local = 1.22573e-10, global = -5.74984e-12, cumulative = 6.03877e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000894007, Final residual = 4.71889e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000998404, Final residual = 6.26446e-06, No Iterations 6
ExecutionTime = 34.52 s ClockTime = 35 s
Time = 3.34
Courant Number mean: 0.117878 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000502583, Final residual = 9.39877e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00117343, Final residual = 9.97112e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00276445, Final residual = 0.000165412, No Iterations 5
time step continuity errors : sum local = 3.49136e-08, global = 2.6906e-09, cumulative = 6.04146e-06
GAMG: Solving for p, Initial residual = 0.00077409, Final residual = 5.84188e-07, No Iterations 21
time step continuity errors : sum local = 1.23013e-10, global = -5.76827e-12, cumulative = 6.04146e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000891165, Final residual = 4.75631e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000995279, Final residual = 6.31784e-06, No Iterations 6
ExecutionTime = 34.55 s ClockTime = 35 s
Time = 3.3425
Courant Number mean: 0.117836 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000500144, Final residual = 9.41555e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00116745, Final residual = 9.99331e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0025182, Final residual = 0.000166829, No Iterations 5
time step continuity errors : sum local = 3.51811e-08, global = 2.73842e-09, cumulative = 6.0442e-06
GAMG: Solving for p, Initial residual = 0.000760499, Final residual = 5.84286e-07, No Iterations 21
time step continuity errors : sum local = 1.22933e-10, global = -5.76366e-12, cumulative = 6.04419e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000888285, Final residual = 4.79545e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000992222, Final residual = 6.37209e-06, No Iterations 6
ExecutionTime = 34.58 s ClockTime = 35 s
Time = 3.345
Courant Number mean: 0.117794 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000497741, Final residual = 9.43229e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00116146, Final residual = 4.75681e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00235599, Final residual = 0.000172195, No Iterations 5
time step continuity errors : sum local = 3.62878e-08, global = 3.19037e-09, cumulative = 6.04738e-06
GAMG: Solving for p, Initial residual = 0.000747747, Final residual = 7.3228e-07, No Iterations 21
time step continuity errors : sum local = 1.53994e-10, global = -7.70643e-12, cumulative = 6.04737e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000885374, Final residual = 4.83044e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000989257, Final residual = 6.42436e-06, No Iterations 6
ExecutionTime = 34.61 s ClockTime = 35 s
Time = 3.3475
Courant Number mean: 0.117753 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000495414, Final residual = 9.45009e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00115476, Final residual = 4.75892e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00245322, Final residual = 0.000172771, No Iterations 5
time step continuity errors : sum local = 3.63815e-08, global = 3.1298e-09, cumulative = 6.0505e-06
GAMG: Solving for p, Initial residual = 0.00075662, Final residual = 6.9735e-07, No Iterations 21
time step continuity errors : sum local = 1.46524e-10, global = -7.20001e-12, cumulative = 6.0505e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000882322, Final residual = 4.86681e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000986221, Final residual = 6.47839e-06, No Iterations 6
ExecutionTime = 34.64 s ClockTime = 35 s
Time = 3.35
Courant Number mean: 0.117712 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000492958, Final residual = 9.46553e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00114906, Final residual = 4.78256e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00236187, Final residual = 0.000173272, No Iterations 5
time step continuity errors : sum local = 3.64584e-08, global = 3.16901e-09, cumulative = 6.05366e-06
GAMG: Solving for p, Initial residual = 0.000751, Final residual = 7.08455e-07, No Iterations 21
time step continuity errors : sum local = 1.48731e-10, global = -7.34457e-12, cumulative = 6.05366e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000879527, Final residual = 4.90339e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00098327, Final residual = 6.53323e-06, No Iterations 6
ExecutionTime = 34.67 s ClockTime = 35 s
Time = 3.3525
Courant Number mean: 0.117671 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000490566, Final residual = 9.48142e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0011431, Final residual = 4.79743e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00250433, Final residual = 0.000174414, No Iterations 5
time step continuity errors : sum local = 3.6676e-08, global = 3.14738e-09, cumulative = 6.0568e-06
GAMG: Solving for p, Initial residual = 0.000769765, Final residual = 7.05098e-07, No Iterations 21
time step continuity errors : sum local = 1.47958e-10, global = -7.26607e-12, cumulative = 6.0568e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000876847, Final residual = 4.93961e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000980256, Final residual = 6.58766e-06, No Iterations 6
ExecutionTime = 34.7 s ClockTime = 35 s
Time = 3.355
Courant Number mean: 0.117631 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000488135, Final residual = 9.49685e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00113764, Final residual = 4.81659e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00261689, Final residual = 0.000174187, No Iterations 5
time step continuity errors : sum local = 3.66075e-08, global = 3.01622e-09, cumulative = 6.05981e-06
GAMG: Solving for p, Initial residual = 0.000769516, Final residual = 7.12259e-07, No Iterations 21
time step continuity errors : sum local = 1.49339e-10, global = -7.29658e-12, cumulative = 6.05981e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000873996, Final residual = 4.97801e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000977047, Final residual = 6.64265e-06, No Iterations 6
ExecutionTime = 34.72 s ClockTime = 35 s
Time = 3.3575
Courant Number mean: 0.11759 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000485663, Final residual = 9.51105e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00113166, Final residual = 4.83385e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00244488, Final residual = 0.000175219, No Iterations 5
time step continuity errors : sum local = 3.67927e-08, global = 3.00559e-09, cumulative = 6.06281e-06
GAMG: Solving for p, Initial residual = 0.000763062, Final residual = 7.14877e-07, No Iterations 21
time step continuity errors : sum local = 1.49751e-10, global = -7.27987e-12, cumulative = 6.0628e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000871056, Final residual = 5.0156e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000973929, Final residual = 6.69976e-06, No Iterations 6
ExecutionTime = 34.75 s ClockTime = 35 s
Time = 3.36
Courant Number mean: 0.11755 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000483233, Final residual = 9.52526e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00112575, Final residual = 4.85159e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00236241, Final residual = 0.000176372, No Iterations 5
time step continuity errors : sum local = 3.70016e-08, global = 3.0363e-09, cumulative = 6.06584e-06
GAMG: Solving for p, Initial residual = 0.000762853, Final residual = 7.16567e-07, No Iterations 21
time step continuity errors : sum local = 1.49975e-10, global = -7.28137e-12, cumulative = 6.06583e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000868273, Final residual = 5.04985e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000970927, Final residual = 6.75426e-06, No Iterations 6
ExecutionTime = 34.78 s ClockTime = 35 s
Time = 3.3625
Courant Number mean: 0.117511 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000480831, Final residual = 9.5391e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00111981, Final residual = 4.86852e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00258203, Final residual = 0.000177103, No Iterations 5
time step continuity errors : sum local = 3.71192e-08, global = 3.0191e-09, cumulative = 6.06885e-06
GAMG: Solving for p, Initial residual = 0.000788713, Final residual = 7.18289e-07, No Iterations 21
time step continuity errors : sum local = 1.50181e-10, global = -7.27257e-12, cumulative = 6.06885e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000865305, Final residual = 5.08586e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000967869, Final residual = 6.80931e-06, No Iterations 6
ExecutionTime = 34.81 s ClockTime = 35 s
Time = 3.365
Courant Number mean: 0.117471 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000478373, Final residual = 9.55221e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0011139, Final residual = 4.88588e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00257667, Final residual = 0.00017783, No Iterations 5
time step continuity errors : sum local = 3.72386e-08, global = 3.05488e-09, cumulative = 6.0719e-06
GAMG: Solving for p, Initial residual = 0.000790508, Final residual = 7.18782e-07, No Iterations 21
time step continuity errors : sum local = 1.50164e-10, global = -7.26847e-12, cumulative = 6.07189e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000862317, Final residual = 5.12129e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00096483, Final residual = 6.86384e-06, No Iterations 6
ExecutionTime = 34.84 s ClockTime = 35 s
Time = 3.3675
Courant Number mean: 0.117432 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000475893, Final residual = 9.56531e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00110796, Final residual = 4.90254e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00231825, Final residual = 0.000178347, No Iterations 5
time step continuity errors : sum local = 3.73231e-08, global = 3.09976e-09, cumulative = 6.07499e-06
GAMG: Solving for p, Initial residual = 0.000774703, Final residual = 7.17312e-07, No Iterations 21
time step continuity errors : sum local = 1.49782e-10, global = -7.2397e-12, cumulative = 6.07499e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000859521, Final residual = 5.15785e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000961778, Final residual = 6.91647e-06, No Iterations 6
ExecutionTime = 34.86 s ClockTime = 35 s
Time = 3.37
Courant Number mean: 0.117393 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000473425, Final residual = 9.5781e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00110205, Final residual = 4.91895e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00236577, Final residual = 0.000179586, No Iterations 5
time step continuity errors : sum local = 3.75658e-08, global = 3.17756e-09, cumulative = 6.07816e-06
GAMG: Solving for p, Initial residual = 0.000773917, Final residual = 7.13135e-07, No Iterations 21
time step continuity errors : sum local = 1.4885e-10, global = -7.19506e-12, cumulative = 6.07816e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000856905, Final residual = 5.19298e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000958665, Final residual = 6.97055e-06, No Iterations 6
ExecutionTime = 34.89 s ClockTime = 35 s
Time = 3.3725
Courant Number mean: 0.117355 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000470926, Final residual = 9.59046e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00109637, Final residual = 4.93496e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00233998, Final residual = 0.000180146, No Iterations 5
time step continuity errors : sum local = 3.76589e-08, global = 3.23373e-09, cumulative = 6.08139e-06
GAMG: Solving for p, Initial residual = 0.000765846, Final residual = 7.09126e-07, No Iterations 21
time step continuity errors : sum local = 1.47896e-10, global = -7.14685e-12, cumulative = 6.08138e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000854291, Final residual = 5.22748e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000955465, Final residual = 7.02542e-06, No Iterations 6
ExecutionTime = 34.92 s ClockTime = 35 s
Time = 3.375
Courant Number mean: 0.117316 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000468494, Final residual = 9.60238e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00109036, Final residual = 4.95146e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00226356, Final residual = 0.000180351, No Iterations 5
time step continuity errors : sum local = 3.76734e-08, global = 3.26599e-09, cumulative = 6.08465e-06
GAMG: Solving for p, Initial residual = 0.000756529, Final residual = 7.07946e-07, No Iterations 21
time step continuity errors : sum local = 1.47543e-10, global = -7.12144e-12, cumulative = 6.08464e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000851438, Final residual = 5.2634e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000952338, Final residual = 7.07995e-06, No Iterations 6
ExecutionTime = 34.94 s ClockTime = 35 s
Time = 3.3775
Courant Number mean: 0.117278 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000466063, Final residual = 9.6138e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00108443, Final residual = 4.9677e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00231663, Final residual = 0.000180659, No Iterations 5
time step continuity errors : sum local = 3.77041e-08, global = 3.28209e-09, cumulative = 6.08792e-06
GAMG: Solving for p, Initial residual = 0.00076464, Final residual = 7.07705e-07, No Iterations 21
time step continuity errors : sum local = 1.47345e-10, global = -7.09907e-12, cumulative = 6.08792e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00084855, Final residual = 5.30221e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000949239, Final residual = 7.1339e-06, No Iterations 6
ExecutionTime = 34.97 s ClockTime = 35 s
Time = 3.38
Courant Number mean: 0.11724 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000463605, Final residual = 9.62429e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00107847, Final residual = 4.98385e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00239785, Final residual = 0.000181102, No Iterations 5
time step continuity errors : sum local = 3.77575e-08, global = 3.26284e-09, cumulative = 6.09118e-06
GAMG: Solving for p, Initial residual = 0.000772704, Final residual = 7.09368e-07, No Iterations 21
time step continuity errors : sum local = 1.47528e-10, global = -7.09928e-12, cumulative = 6.09117e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000845573, Final residual = 5.33349e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000946171, Final residual = 7.18858e-06, No Iterations 6
ExecutionTime = 34.99 s ClockTime = 35 s
Time = 3.3825
Courant Number mean: 0.117202 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000461146, Final residual = 9.63437e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00107262, Final residual = 4.99957e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00252998, Final residual = 0.000182616, No Iterations 5
time step continuity errors : sum local = 3.80379e-08, global = 3.288e-09, cumulative = 6.09446e-06
GAMG: Solving for p, Initial residual = 0.00079518, Final residual = 7.1211e-07, No Iterations 21
time step continuity errors : sum local = 1.47991e-10, global = -7.12219e-12, cumulative = 6.09445e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000842603, Final residual = 5.36868e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000943089, Final residual = 7.24363e-06, No Iterations 6
ExecutionTime = 35.02 s ClockTime = 35 s
Time = 3.385
Courant Number mean: 0.117165 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000458678, Final residual = 9.64437e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00106676, Final residual = 5.01492e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00253412, Final residual = 0.000183737, No Iterations 5
time step continuity errors : sum local = 3.82456e-08, global = 3.33482e-09, cumulative = 6.09779e-06
GAMG: Solving for p, Initial residual = 0.000792829, Final residual = 7.1101e-07, No Iterations 21
time step continuity errors : sum local = 1.47678e-10, global = -7.10439e-12, cumulative = 6.09778e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000839791, Final residual = 5.40365e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000940024, Final residual = 7.29707e-06, No Iterations 6
ExecutionTime = 35.04 s ClockTime = 35 s
Time = 3.3875
Courant Number mean: 0.117127 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000456199, Final residual = 9.6539e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00106091, Final residual = 5.02963e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00223303, Final residual = 0.00018436, No Iterations 5
time step continuity errors : sum local = 3.83564e-08, global = 3.37247e-09, cumulative = 6.10115e-06
GAMG: Solving for p, Initial residual = 0.00077586, Final residual = 7.09357e-07, No Iterations 21
time step continuity errors : sum local = 1.47269e-10, global = -7.08296e-12, cumulative = 6.10115e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000837166, Final residual = 5.43816e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000936818, Final residual = 7.35099e-06, No Iterations 6
ExecutionTime = 35.09 s ClockTime = 35 s
Time = 3.39
Courant Number mean: 0.11709 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000453746, Final residual = 9.66256e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00105495, Final residual = 5.04393e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00232672, Final residual = 0.000185673, No Iterations 5
time step continuity errors : sum local = 3.86071e-08, global = 3.42624e-09, cumulative = 6.10457e-06
GAMG: Solving for p, Initial residual = 0.000784765, Final residual = 7.09142e-07, No Iterations 21
time step continuity errors : sum local = 1.4712e-10, global = -7.0777e-12, cumulative = 6.10457e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000834496, Final residual = 5.47136e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000933593, Final residual = 7.40414e-06, No Iterations 6
ExecutionTime = 35.12 s ClockTime = 35 s
Time = 3.3925
Courant Number mean: 0.117053 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000451246, Final residual = 9.67104e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00104896, Final residual = 5.05873e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00234418, Final residual = 0.000186994, No Iterations 5
time step continuity errors : sum local = 3.88532e-08, global = 3.54645e-09, cumulative = 6.10811e-06
GAMG: Solving for p, Initial residual = 0.000774315, Final residual = 7.0582e-07, No Iterations 21
time step continuity errors : sum local = 1.46319e-10, global = -7.04982e-12, cumulative = 6.1081e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000831656, Final residual = 5.50573e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000930486, Final residual = 7.4576e-06, No Iterations 6
ExecutionTime = 35.14 s ClockTime = 35 s
Time = 3.395
Courant Number mean: 0.117017 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000448774, Final residual = 9.67906e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00104302, Final residual = 5.07325e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.0024052, Final residual = 0.000187269, No Iterations 5
time step continuity errors : sum local = 3.88776e-08, global = 3.5752e-09, cumulative = 6.11168e-06
GAMG: Solving for p, Initial residual = 0.000772718, Final residual = 7.01987e-07, No Iterations 21
time step continuity errors : sum local = 1.454e-10, global = -6.9995e-12, cumulative = 6.11167e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000828723, Final residual = 5.53789e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000927439, Final residual = 7.51093e-06, No Iterations 6
ExecutionTime = 35.17 s ClockTime = 35 s
Time = 3.3975
Courant Number mean: 0.11698 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000446277, Final residual = 9.68627e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0010371, Final residual = 5.08705e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00230657, Final residual = 0.000187233, No Iterations 5
time step continuity errors : sum local = 3.88356e-08, global = 3.5734e-09, cumulative = 6.11525e-06
GAMG: Solving for p, Initial residual = 0.000766929, Final residual = 7.03918e-07, No Iterations 21
time step continuity errors : sum local = 1.45664e-10, global = -7.00763e-12, cumulative = 6.11524e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000825777, Final residual = 5.57456e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000924361, Final residual = 7.56458e-06, No Iterations 6
ExecutionTime = 35.2 s ClockTime = 35 s
Time = 3.4
Courant Number mean: 0.116944 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000443802, Final residual = 9.69285e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00103123, Final residual = 5.10074e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00237283, Final residual = 0.000188044, No Iterations 5
time step continuity errors : sum local = 3.89747e-08, global = 3.61204e-09, cumulative = 6.11885e-06
GAMG: Solving for p, Initial residual = 0.000777899, Final residual = 7.04081e-07, No Iterations 21
time step continuity errors : sum local = 1.45605e-10, global = -7.00408e-12, cumulative = 6.11884e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000822873, Final residual = 5.60697e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000921288, Final residual = 7.61831e-06, No Iterations 6
ExecutionTime = 35.25 s ClockTime = 36 s
Time = 3.4025
Courant Number mean: 0.116908 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000441309, Final residual = 9.69915e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00102536, Final residual = 5.11346e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00233413, Final residual = 0.000189191, No Iterations 5
time step continuity errors : sum local = 3.91861e-08, global = 3.65031e-09, cumulative = 6.12249e-06
GAMG: Solving for p, Initial residual = 0.000782879, Final residual = 7.05498e-07, No Iterations 21
time step continuity errors : sum local = 1.45804e-10, global = -7.02719e-12, cumulative = 6.12249e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000820021, Final residual = 5.63737e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000918157, Final residual = 7.67055e-06, No Iterations 6
ExecutionTime = 35.28 s ClockTime = 36 s
Time = 3.405
Courant Number mean: 0.116872 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000438829, Final residual = 9.70446e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00101949, Final residual = 5.12637e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00230284, Final residual = 0.000188174, No Iterations 5
time step continuity errors : sum local = 3.89551e-08, global = 3.60586e-09, cumulative = 6.12609e-06
GAMG: Solving for p, Initial residual = 0.000789381, Final residual = 7.05994e-07, No Iterations 21
time step continuity errors : sum local = 1.45859e-10, global = -7.00969e-12, cumulative = 6.12609e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000817336, Final residual = 5.6701e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000914959, Final residual = 7.72191e-06, No Iterations 6
ExecutionTime = 35.31 s ClockTime = 36 s
Time = 3.4075
Courant Number mean: 0.116836 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000436331, Final residual = 9.70899e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00101365, Final residual = 5.13891e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00222012, Final residual = 0.000189924, No Iterations 5
time step continuity errors : sum local = 3.93013e-08, global = 3.59572e-09, cumulative = 6.12968e-06
GAMG: Solving for p, Initial residual = 0.000782419, Final residual = 7.06635e-07, No Iterations 21
time step continuity errors : sum local = 1.45903e-10, global = -7.00723e-12, cumulative = 6.12968e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000814597, Final residual = 5.70494e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000911885, Final residual = 7.77339e-06, No Iterations 6
ExecutionTime = 35.34 s ClockTime = 36 s
Time = 3.41
Courant Number mean: 0.116801 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.00043385, Final residual = 9.71337e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00100782, Final residual = 5.15204e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00226463, Final residual = 0.000191099, No Iterations 5
time step continuity errors : sum local = 3.95152e-08, global = 3.68429e-09, cumulative = 6.13336e-06
GAMG: Solving for p, Initial residual = 0.000778148, Final residual = 7.04821e-07, No Iterations 21
time step continuity errors : sum local = 1.45415e-10, global = -6.9846e-12, cumulative = 6.13335e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000811685, Final residual = 5.73334e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000908854, Final residual = 7.82406e-06, No Iterations 6
ExecutionTime = 35.37 s ClockTime = 36 s
Time = 3.4125
Courant Number mean: 0.116765 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000431355, Final residual = 9.71746e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00100195, Final residual = 5.16366e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00224793, Final residual = 0.000189839, No Iterations 5
time step continuity errors : sum local = 3.92213e-08, global = 3.65505e-09, cumulative = 6.13701e-06
GAMG: Solving for p, Initial residual = 0.000775673, Final residual = 7.04987e-07, No Iterations 21
time step continuity errors : sum local = 1.45311e-10, global = -6.96558e-12, cumulative = 6.137e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000808836, Final residual = 5.7657e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000905786, Final residual = 7.87632e-06, No Iterations 6
ExecutionTime = 35.39 s ClockTime = 36 s
Time = 3.415
Courant Number mean: 0.11673 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000428859, Final residual = 9.72031e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000996027, Final residual = 5.17583e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00237377, Final residual = 0.000190637, No Iterations 5
time step continuity errors : sum local = 3.93525e-08, global = 3.65873e-09, cumulative = 6.14066e-06
GAMG: Solving for p, Initial residual = 0.000790416, Final residual = 7.07293e-07, No Iterations 21
time step continuity errors : sum local = 1.45664e-10, global = -6.97109e-12, cumulative = 6.14065e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000806003, Final residual = 5.79428e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000902756, Final residual = 7.92534e-06, No Iterations 6
ExecutionTime = 35.42 s ClockTime = 36 s
Time = 3.4175
Courant Number mean: 0.116695 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000426368, Final residual = 9.72259e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000990215, Final residual = 5.18728e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00228536, Final residual = 0.00019149, No Iterations 5
time step continuity errors : sum local = 3.95026e-08, global = 3.6628e-09, cumulative = 6.14432e-06
GAMG: Solving for p, Initial residual = 0.000786265, Final residual = 7.08659e-07, No Iterations 21
time step continuity errors : sum local = 1.45872e-10, global = -6.98132e-12, cumulative = 6.14431e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000803071, Final residual = 5.82158e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000899692, Final residual = 7.97509e-06, No Iterations 6
ExecutionTime = 35.44 s ClockTime = 36 s
Time = 3.42
Courant Number mean: 0.116661 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000423896, Final residual = 9.72469e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000984398, Final residual = 5.19827e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00221635, Final residual = 0.000191598, No Iterations 5
time step continuity errors : sum local = 3.95047e-08, global = 3.6702e-09, cumulative = 6.14798e-06
GAMG: Solving for p, Initial residual = 0.000779015, Final residual = 7.08784e-07, No Iterations 21
time step continuity errors : sum local = 1.45824e-10, global = -6.97149e-12, cumulative = 6.14797e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000800213, Final residual = 5.85577e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000896606, Final residual = 8.02459e-06, No Iterations 6
ExecutionTime = 35.47 s ClockTime = 36 s
Time = 3.4225
Courant Number mean: 0.116626 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000421417, Final residual = 9.72612e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000978415, Final residual = 5.20845e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00210442, Final residual = 0.000192032, No Iterations 5
time step continuity errors : sum local = 3.95751e-08, global = 3.72024e-09, cumulative = 6.15169e-06
GAMG: Solving for p, Initial residual = 0.000775221, Final residual = 7.07989e-07, No Iterations 21
time step continuity errors : sum local = 1.45595e-10, global = -6.95514e-12, cumulative = 6.15168e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000797582, Final residual = 5.8854e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000893463, Final residual = 8.0753e-06, No Iterations 6
ExecutionTime = 35.5 s ClockTime = 36 s
Time = 3.425
Courant Number mean: 0.116592 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000418922, Final residual = 9.72702e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000972652, Final residual = 5.21854e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00209682, Final residual = 0.00019235, No Iterations 5
time step continuity errors : sum local = 3.96179e-08, global = 3.66955e-09, cumulative = 6.15535e-06
GAMG: Solving for p, Initial residual = 0.000777014, Final residual = 7.08518e-07, No Iterations 21
time step continuity errors : sum local = 1.45619e-10, global = -6.94673e-12, cumulative = 6.15535e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000795096, Final residual = 5.91446e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000890369, Final residual = 8.12402e-06, No Iterations 6
ExecutionTime = 35.52 s ClockTime = 36 s
Time = 3.4275
Courant Number mean: 0.116558 max: 0.616696
smoothSolver: Solving for Ux, Initial residual = 0.000416426, Final residual = 9.72687e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0009667, Final residual = 5.22849e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00221628, Final residual = 0.000193782, No Iterations 5
time step continuity errors : sum local = 3.98866e-08, global = 3.66556e-09, cumulative = 6.15901e-06
GAMG: Solving for p, Initial residual = 0.000792522, Final residual = 7.13083e-07, No Iterations 21
time step continuity errors : sum local = 1.46431e-10, global = -7.00292e-12, cumulative = 6.15901e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000792353, Final residual = 5.9371e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000887308, Final residual = 8.17256e-06, No Iterations 6
ExecutionTime = 35.56 s ClockTime = 36 s
Time = 3.43
Courant Number mean: 0.116524 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000413937, Final residual = 9.72641e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000960887, Final residual = 5.23845e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00220624, Final residual = 0.000193389, No Iterations 5
time step continuity errors : sum local = 3.97711e-08, global = 3.63273e-09, cumulative = 6.16264e-06
GAMG: Solving for p, Initial residual = 0.000791386, Final residual = 7.1688e-07, No Iterations 21
time step continuity errors : sum local = 1.47083e-10, global = -7.02515e-12, cumulative = 6.16263e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000789456, Final residual = 5.96618e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000884238, Final residual = 8.22078e-06, No Iterations 6
ExecutionTime = 35.58 s ClockTime = 36 s
Time = 3.4325
Courant Number mean: 0.116491 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000411424, Final residual = 9.72472e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000955183, Final residual = 5.24757e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.0021608, Final residual = 0.000194096, No Iterations 5
time step continuity errors : sum local = 3.98868e-08, global = 3.65589e-09, cumulative = 6.16629e-06
GAMG: Solving for p, Initial residual = 0.000786961, Final residual = 7.17375e-07, No Iterations 21
time step continuity errors : sum local = 1.47074e-10, global = -7.01715e-12, cumulative = 6.16628e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000786551, Final residual = 5.99721e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000881175, Final residual = 8.26764e-06, No Iterations 6
ExecutionTime = 35.61 s ClockTime = 36 s
Time = 3.435
Courant Number mean: 0.116457 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000408902, Final residual = 9.72272e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000949273, Final residual = 5.25563e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00216567, Final residual = 0.000194848, No Iterations 5
time step continuity errors : sum local = 4.00121e-08, global = 3.67145e-09, cumulative = 6.16995e-06
GAMG: Solving for p, Initial residual = 0.000784099, Final residual = 7.18627e-07, No Iterations 21
time step continuity errors : sum local = 1.4723e-10, global = -7.03745e-12, cumulative = 6.16994e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000783653, Final residual = 6.02229e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000878057, Final residual = 8.3146e-06, No Iterations 6
ExecutionTime = 35.64 s ClockTime = 36 s
Time = 3.4375
Courant Number mean: 0.116424 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000406425, Final residual = 9.72051e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000943229, Final residual = 5.26327e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00213244, Final residual = 0.000194317, No Iterations 5
time step continuity errors : sum local = 3.98798e-08, global = 3.69199e-09, cumulative = 6.17364e-06
GAMG: Solving for p, Initial residual = 0.000782474, Final residual = 7.17434e-07, No Iterations 21
time step continuity errors : sum local = 1.46917e-10, global = -7.00484e-12, cumulative = 6.17363e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000780819, Final residual = 6.04888e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000874883, Final residual = 8.36072e-06, No Iterations 6
ExecutionTime = 35.67 s ClockTime = 36 s
Time = 3.44
Courant Number mean: 0.116391 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000403971, Final residual = 9.71727e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000937005, Final residual = 5.26996e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00209167, Final residual = 0.000194734, No Iterations 5
time step continuity errors : sum local = 3.9942e-08, global = 3.75272e-09, cumulative = 6.17738e-06
GAMG: Solving for p, Initial residual = 0.000782695, Final residual = 7.15396e-07, No Iterations 21
time step continuity errors : sum local = 1.46408e-10, global = -6.97272e-12, cumulative = 6.17738e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000778012, Final residual = 6.07232e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000871864, Final residual = 8.40695e-06, No Iterations 6
ExecutionTime = 35.7 s ClockTime = 36 s
Time = 3.4425
Courant Number mean: 0.116358 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000401483, Final residual = 9.71383e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000931019, Final residual = 5.27593e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00217708, Final residual = 0.000194634, No Iterations 5
time step continuity errors : sum local = 3.98922e-08, global = 3.77219e-09, cumulative = 6.18115e-06
GAMG: Solving for p, Initial residual = 0.000798849, Final residual = 7.14163e-07, No Iterations 21
time step continuity errors : sum local = 1.46039e-10, global = -6.94899e-12, cumulative = 6.18114e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000775408, Final residual = 6.09275e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00086885, Final residual = 8.45286e-06, No Iterations 6
ExecutionTime = 35.72 s ClockTime = 36 s
Time = 3.445
Courant Number mean: 0.116325 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000398979, Final residual = 9.70934e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000925155, Final residual = 5.28219e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00200757, Final residual = 0.000195472, No Iterations 5
time step continuity errors : sum local = 4.00329e-08, global = 3.75684e-09, cumulative = 6.1849e-06
GAMG: Solving for p, Initial residual = 0.000783507, Final residual = 7.15518e-07, No Iterations 21
time step continuity errors : sum local = 1.46198e-10, global = -6.96221e-12, cumulative = 6.18489e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000772659, Final residual = 6.12057e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000865832, Final residual = 8.49645e-06, No Iterations 6
ExecutionTime = 35.75 s ClockTime = 36 s
Time = 3.4475
Courant Number mean: 0.116293 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000396474, Final residual = 9.7041e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000919289, Final residual = 5.28867e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00209451, Final residual = 0.0001959, No Iterations 5
time step continuity errors : sum local = 4.0089e-08, global = 3.73422e-09, cumulative = 6.18862e-06
GAMG: Solving for p, Initial residual = 0.000786749, Final residual = 7.18651e-07, No Iterations 21
time step continuity errors : sum local = 1.46714e-10, global = -6.98456e-12, cumulative = 6.18862e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000769909, Final residual = 6.14503e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000862803, Final residual = 8.54014e-06, No Iterations 6
ExecutionTime = 35.78 s ClockTime = 36 s
Time = 3.45
Courant Number mean: 0.116261 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000394021, Final residual = 9.69804e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000913509, Final residual = 5.29493e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00212681, Final residual = 0.000196169, No Iterations 5
time step continuity errors : sum local = 4.01148e-08, global = 3.79992e-09, cumulative = 6.19242e-06
GAMG: Solving for p, Initial residual = 0.000791989, Final residual = 7.16408e-07, No Iterations 21
time step continuity errors : sum local = 1.46171e-10, global = -6.95513e-12, cumulative = 6.19241e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000767102, Final residual = 6.16313e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000859783, Final residual = 8.58259e-06, No Iterations 6
ExecutionTime = 35.81 s ClockTime = 36 s
Time = 3.4525
Courant Number mean: 0.116229 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000391538, Final residual = 9.6915e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000907646, Final residual = 5.301e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00200639, Final residual = 0.000196845, No Iterations 5
time step continuity errors : sum local = 4.02275e-08, global = 3.84554e-09, cumulative = 6.19626e-06
GAMG: Solving for p, Initial residual = 0.000779088, Final residual = 7.14201e-07, No Iterations 21
time step continuity errors : sum local = 1.45625e-10, global = -6.93583e-12, cumulative = 6.19625e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000764226, Final residual = 6.18726e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000856741, Final residual = 8.62418e-06, No Iterations 6
ExecutionTime = 35.83 s ClockTime = 36 s
Time = 3.455
Courant Number mean: 0.116197 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000389049, Final residual = 9.68433e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00090157, Final residual = 5.30685e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00202328, Final residual = 0.000196927, No Iterations 5
time step continuity errors : sum local = 4.02198e-08, global = 3.86656e-09, cumulative = 6.20012e-06
GAMG: Solving for p, Initial residual = 0.000782217, Final residual = 7.13068e-07, No Iterations 21
time step continuity errors : sum local = 1.45318e-10, global = -6.92238e-12, cumulative = 6.20011e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000761446, Final residual = 6.20889e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000853634, Final residual = 8.66554e-06, No Iterations 6
ExecutionTime = 35.86 s ClockTime = 36 s
Time = 3.4575
Courant Number mean: 0.116165 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000386573, Final residual = 9.67645e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000895403, Final residual = 5.31282e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00207125, Final residual = 0.000197096, No Iterations 5
time step continuity errors : sum local = 4.0229e-08, global = 3.88989e-09, cumulative = 6.204e-06
GAMG: Solving for p, Initial residual = 0.000782311, Final residual = 7.11719e-07, No Iterations 21
time step continuity errors : sum local = 1.44946e-10, global = -6.89932e-12, cumulative = 6.20399e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000758785, Final residual = 6.23198e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000850562, Final residual = 8.70625e-06, No Iterations 6
ExecutionTime = 35.89 s ClockTime = 36 s
Time = 3.46
Courant Number mean: 0.116133 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.00038412, Final residual = 9.66792e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000889174, Final residual = 5.3188e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00205318, Final residual = 0.000197059, No Iterations 5
time step continuity errors : sum local = 4.01917e-08, global = 3.86388e-09, cumulative = 6.20786e-06
GAMG: Solving for p, Initial residual = 0.00079646, Final residual = 7.14843e-07, No Iterations 21
time step continuity errors : sum local = 1.45456e-10, global = -6.92593e-12, cumulative = 6.20785e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000756277, Final residual = 6.2494e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000847515, Final residual = 8.74752e-06, No Iterations 6
ExecutionTime = 35.92 s ClockTime = 36 s
Time = 3.4625
Courant Number mean: 0.116102 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000381642, Final residual = 9.65804e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000883266, Final residual = 5.32521e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00200646, Final residual = 0.000197707, No Iterations 5
time step continuity errors : sum local = 4.02908e-08, global = 3.85663e-09, cumulative = 6.21171e-06
GAMG: Solving for p, Initial residual = 0.000793004, Final residual = 7.17681e-07, No Iterations 21
time step continuity errors : sum local = 1.45922e-10, global = -6.94518e-12, cumulative = 6.2117e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000753631, Final residual = 6.26713e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000844492, Final residual = 8.78728e-06, No Iterations 6
ExecutionTime = 35.94 s ClockTime = 36 s
Time = 3.465
Courant Number mean: 0.11607 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000379145, Final residual = 9.64774e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000877528, Final residual = 5.33086e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.002016, Final residual = 0.000198716, No Iterations 5
time step continuity errors : sum local = 4.04645e-08, global = 3.91323e-09, cumulative = 6.21561e-06
GAMG: Solving for p, Initial residual = 0.000786982, Final residual = 7.15292e-07, No Iterations 21
time step continuity errors : sum local = 1.45317e-10, global = -6.92125e-12, cumulative = 6.21561e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000750685, Final residual = 6.28552e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000841466, Final residual = 8.82578e-06, No Iterations 6
ExecutionTime = 35.97 s ClockTime = 36 s
Time = 3.4675
Courant Number mean: 0.116039 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000376692, Final residual = 9.63718e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000871626, Final residual = 5.33583e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00191227, Final residual = 0.000112106, No Iterations 7
time step continuity errors : sum local = 2.28143e-08, global = 1.32985e-09, cumulative = 6.21693e-06
GAMG: Solving for p, Initial residual = 0.000823393, Final residual = 9.40441e-07, No Iterations 21
time step continuity errors : sum local = 1.90845e-10, global = -9.3084e-12, cumulative = 6.21693e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000747755, Final residual = 6.30266e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000838345, Final residual = 8.86423e-06, No Iterations 6
ExecutionTime = 36 s ClockTime = 36 s
Time = 3.47
Courant Number mean: 0.116009 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000374001, Final residual = 9.60309e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000866935, Final residual = 5.3605e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00199401, Final residual = 0.000132287, No Iterations 7
time step continuity errors : sum local = 2.69181e-08, global = 1.59152e-09, cumulative = 6.21852e-06
GAMG: Solving for p, Initial residual = 0.000904068, Final residual = 5.71128e-07, No Iterations 23
time step continuity errors : sum local = 1.15832e-10, global = -6.02889e-12, cumulative = 6.21851e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000744763, Final residual = 6.32309e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000835183, Final residual = 8.90159e-06, No Iterations 6
ExecutionTime = 36.03 s ClockTime = 36 s
Time = 3.4725
Courant Number mean: 0.115978 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000371598, Final residual = 9.59474e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000860692, Final residual = 5.36522e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00203144, Final residual = 0.000129711, No Iterations 7
time step continuity errors : sum local = 2.63789e-08, global = 1.57498e-09, cumulative = 6.22009e-06
GAMG: Solving for p, Initial residual = 0.000908586, Final residual = 5.71518e-07, No Iterations 23
time step continuity errors : sum local = 1.15849e-10, global = -6.03556e-12, cumulative = 6.22008e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000741812, Final residual = 6.33906e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000832157, Final residual = 8.93788e-06, No Iterations 6
ExecutionTime = 36.06 s ClockTime = 36 s
Time = 3.475
Courant Number mean: 0.115947 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000369116, Final residual = 9.58083e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000854631, Final residual = 5.36938e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00212977, Final residual = 0.000130176, No Iterations 7
time step continuity errors : sum local = 2.64569e-08, global = 1.57481e-09, cumulative = 6.22165e-06
GAMG: Solving for p, Initial residual = 0.000918448, Final residual = 5.719e-07, No Iterations 23
time step continuity errors : sum local = 1.15847e-10, global = -6.02576e-12, cumulative = 6.22165e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000738925, Final residual = 6.35347e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000829188, Final residual = 8.97317e-06, No Iterations 6
ExecutionTime = 36.09 s ClockTime = 36 s
Time = 3.4775
Courant Number mean: 0.115917 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000366696, Final residual = 9.56773e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000848663, Final residual = 5.37306e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00223726, Final residual = 0.000129119, No Iterations 7
time step continuity errors : sum local = 2.62223e-08, global = 1.57172e-09, cumulative = 6.22322e-06
GAMG: Solving for p, Initial residual = 0.000927977, Final residual = 5.71844e-07, No Iterations 23
time step continuity errors : sum local = 1.15732e-10, global = -6.012e-12, cumulative = 6.22321e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000735941, Final residual = 6.36541e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000826151, Final residual = 9.00985e-06, No Iterations 6
ExecutionTime = 36.12 s ClockTime = 36 s
Time = 3.48
Courant Number mean: 0.115886 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000364256, Final residual = 9.55282e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00084269, Final residual = 5.37702e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00219706, Final residual = 0.000130537, No Iterations 7
time step continuity errors : sum local = 2.64856e-08, global = 1.5929e-09, cumulative = 6.22481e-06
GAMG: Solving for p, Initial residual = 0.000933912, Final residual = 5.71503e-07, No Iterations 23
time step continuity errors : sum local = 1.1555e-10, global = -5.99906e-12, cumulative = 6.2248e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000733112, Final residual = 6.38061e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00082317, Final residual = 9.04299e-06, No Iterations 6
ExecutionTime = 36.15 s ClockTime = 36 s
Time = 3.4825
Courant Number mean: 0.115856 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000361805, Final residual = 9.53768e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000836803, Final residual = 5.38e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00210998, Final residual = 0.000129448, No Iterations 7
time step continuity errors : sum local = 2.6244e-08, global = 1.56277e-09, cumulative = 6.22636e-06
GAMG: Solving for p, Initial residual = 0.000923132, Final residual = 5.71948e-07, No Iterations 23
time step continuity errors : sum local = 1.15573e-10, global = -5.99634e-12, cumulative = 6.22636e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000730196, Final residual = 6.39719e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000820246, Final residual = 9.07563e-06, No Iterations 6
ExecutionTime = 36.18 s ClockTime = 36 s
Time = 3.485
Courant Number mean: 0.115826 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.00035934, Final residual = 9.52117e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000831171, Final residual = 5.38303e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00207659, Final residual = 0.000129017, No Iterations 7
time step continuity errors : sum local = 2.61434e-08, global = 1.55822e-09, cumulative = 6.22792e-06
GAMG: Solving for p, Initial residual = 0.000907298, Final residual = 5.73371e-07, No Iterations 23
time step continuity errors : sum local = 1.15808e-10, global = -6.0065e-12, cumulative = 6.22791e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000727235, Final residual = 6.41191e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000817261, Final residual = 9.10763e-06, No Iterations 6
ExecutionTime = 36.21 s ClockTime = 36 s
Time = 3.4875
Courant Number mean: 0.115796 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000356925, Final residual = 9.50434e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000825334, Final residual = 5.38485e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00190374, Final residual = 0.000130686, No Iterations 7
time step continuity errors : sum local = 2.64736e-08, global = 1.5917e-09, cumulative = 6.2295e-06
GAMG: Solving for p, Initial residual = 0.000903547, Final residual = 5.72564e-07, No Iterations 23
time step continuity errors : sum local = 1.15624e-10, global = -5.98942e-12, cumulative = 6.2295e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000724165, Final residual = 6.42098e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000814032, Final residual = 9.13899e-06, No Iterations 6
ExecutionTime = 36.24 s ClockTime = 36 s
Time = 3.49
Courant Number mean: 0.115767 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000354478, Final residual = 9.48733e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000819539, Final residual = 5.38709e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00196558, Final residual = 0.000130826, No Iterations 7
time step continuity errors : sum local = 2.64948e-08, global = 1.58455e-09, cumulative = 6.23108e-06
GAMG: Solving for p, Initial residual = 0.000914444, Final residual = 5.72335e-07, No Iterations 23
time step continuity errors : sum local = 1.15549e-10, global = -5.98243e-12, cumulative = 6.23107e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00072113, Final residual = 6.42969e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000810915, Final residual = 9.17072e-06, No Iterations 6
ExecutionTime = 36.27 s ClockTime = 37 s
Time = 3.4925
Courant Number mean: 0.115737 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000352036, Final residual = 9.46901e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000813595, Final residual = 5.38895e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00192814, Final residual = 0.000130416, No Iterations 7
time step continuity errors : sum local = 2.63998e-08, global = 1.58297e-09, cumulative = 6.23266e-06
GAMG: Solving for p, Initial residual = 0.000906193, Final residual = 5.72788e-07, No Iterations 23
time step continuity errors : sum local = 1.1556e-10, global = -5.97704e-12, cumulative = 6.23265e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000718255, Final residual = 6.44116e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000807928, Final residual = 9.20132e-06, No Iterations 6
ExecutionTime = 36.3 s ClockTime = 37 s
Time = 3.495
Courant Number mean: 0.115708 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000349597, Final residual = 9.44982e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000807553, Final residual = 5.39039e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00207205, Final residual = 0.000130091, No Iterations 7
time step continuity errors : sum local = 2.6316e-08, global = 1.57734e-09, cumulative = 6.23423e-06
GAMG: Solving for p, Initial residual = 0.000913089, Final residual = 5.73695e-07, No Iterations 23
time step continuity errors : sum local = 1.15663e-10, global = -5.97771e-12, cumulative = 6.23422e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000715315, Final residual = 6.45108e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000804877, Final residual = 9.23273e-06, No Iterations 6
ExecutionTime = 36.33 s ClockTime = 37 s
Time = 3.4975
Courant Number mean: 0.115679 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000347153, Final residual = 9.43013e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000801617, Final residual = 5.39218e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00208725, Final residual = 0.000130264, No Iterations 7
time step continuity errors : sum local = 2.63322e-08, global = 1.57618e-09, cumulative = 6.2358e-06
GAMG: Solving for p, Initial residual = 0.000916676, Final residual = 5.74689e-07, No Iterations 23
time step continuity errors : sum local = 1.15781e-10, global = -5.98442e-12, cumulative = 6.23579e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000712334, Final residual = 6.45961e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000801729, Final residual = 9.26261e-06, No Iterations 6
ExecutionTime = 36.35 s ClockTime = 37 s
Time = 3.5
Courant Number mean: 0.11565 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000344719, Final residual = 9.40913e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00079576, Final residual = 5.3929e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00225115, Final residual = 0.0001304, No Iterations 7
time step continuity errors : sum local = 2.63393e-08, global = 1.58176e-09, cumulative = 6.23737e-06
GAMG: Solving for p, Initial residual = 0.000941249, Final residual = 5.753e-07, No Iterations 23
time step continuity errors : sum local = 1.15809e-10, global = -5.98327e-12, cumulative = 6.23737e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000709247, Final residual = 6.46779e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000798663, Final residual = 9.28968e-06, No Iterations 6
ExecutionTime = 36.4 s ClockTime = 37 s
Time = 3.5025
Courant Number mean: 0.115621 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000342289, Final residual = 9.38749e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000789972, Final residual = 5.39362e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00223968, Final residual = 0.000129468, No Iterations 7
time step continuity errors : sum local = 2.61344e-08, global = 1.56372e-09, cumulative = 6.23893e-06
GAMG: Solving for p, Initial residual = 0.000935519, Final residual = 5.7596e-07, No Iterations 23
time step continuity errors : sum local = 1.15887e-10, global = -5.99225e-12, cumulative = 6.23893e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000706139, Final residual = 6.47521e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000795587, Final residual = 9.31389e-06, No Iterations 6
ExecutionTime = 36.43 s ClockTime = 37 s
Time = 3.505
Courant Number mean: 0.115592 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000339878, Final residual = 9.36523e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000784144, Final residual = 5.39464e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00194449, Final residual = 0.00013003, No Iterations 7
time step continuity errors : sum local = 2.62374e-08, global = 1.58233e-09, cumulative = 6.24051e-06
GAMG: Solving for p, Initial residual = 0.000909963, Final residual = 5.75189e-07, No Iterations 23
time step continuity errors : sum local = 1.15692e-10, global = -5.97403e-12, cumulative = 6.2405e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000702929, Final residual = 6.48195e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000792405, Final residual = 9.34047e-06, No Iterations 6
ExecutionTime = 36.46 s ClockTime = 37 s
Time = 3.5075
Courant Number mean: 0.115563 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000337483, Final residual = 9.34295e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000778423, Final residual = 5.39508e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00204596, Final residual = 0.000129457, No Iterations 7
time step continuity errors : sum local = 2.61093e-08, global = 1.56446e-09, cumulative = 6.24207e-06
GAMG: Solving for p, Initial residual = 0.000912089, Final residual = 5.74869e-07, No Iterations 23
time step continuity errors : sum local = 1.15572e-10, global = -5.96468e-12, cumulative = 6.24206e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000699725, Final residual = 6.48512e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000789343, Final residual = 9.3662e-06, No Iterations 6
ExecutionTime = 36.5 s ClockTime = 37 s
Time = 3.51
Courant Number mean: 0.115535 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000335075, Final residual = 9.31958e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00077264, Final residual = 5.39562e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00186232, Final residual = 0.000130561, No Iterations 7
time step continuity errors : sum local = 2.63223e-08, global = 1.59888e-09, cumulative = 6.24366e-06
GAMG: Solving for p, Initial residual = 0.00089795, Final residual = 5.7476e-07, No Iterations 23
time step continuity errors : sum local = 1.15513e-10, global = -5.9622e-12, cumulative = 6.24365e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000696614, Final residual = 6.48994e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000786393, Final residual = 9.38966e-06, No Iterations 6
ExecutionTime = 36.52 s ClockTime = 37 s
Time = 3.5125
Courant Number mean: 0.115506 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000332681, Final residual = 9.29587e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000766784, Final residual = 5.39519e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.0018628, Final residual = 0.000129973, No Iterations 7
time step continuity errors : sum local = 2.61929e-08, global = 1.59482e-09, cumulative = 6.24525e-06
GAMG: Solving for p, Initial residual = 0.000898417, Final residual = 5.74833e-07, No Iterations 23
time step continuity errors : sum local = 1.15469e-10, global = -5.95989e-12, cumulative = 6.24524e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000693414, Final residual = 6.49718e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000783447, Final residual = 9.41103e-06, No Iterations 6
ExecutionTime = 36.55 s ClockTime = 37 s
Time = 3.515
Courant Number mean: 0.115478 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000330269, Final residual = 9.271e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000760784, Final residual = 5.39449e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00211693, Final residual = 0.000129033, No Iterations 7
time step continuity errors : sum local = 2.59858e-08, global = 1.57311e-09, cumulative = 6.24682e-06
GAMG: Solving for p, Initial residual = 0.000930536, Final residual = 5.76414e-07, No Iterations 23
time step continuity errors : sum local = 1.15686e-10, global = -5.97314e-12, cumulative = 6.24681e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00069036, Final residual = 6.50163e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000780418, Final residual = 9.43593e-06, No Iterations 6
ExecutionTime = 36.58 s ClockTime = 37 s
Time = 3.5175
Courant Number mean: 0.11545 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000327859, Final residual = 9.245e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000754847, Final residual = 5.39376e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00196084, Final residual = 0.000129142, No Iterations 7
time step continuity errors : sum local = 2.59886e-08, global = 1.58863e-09, cumulative = 6.2484e-06
GAMG: Solving for p, Initial residual = 0.000909279, Final residual = 5.75455e-07, No Iterations 23
time step continuity errors : sum local = 1.15426e-10, global = -5.95319e-12, cumulative = 6.24839e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000687288, Final residual = 6.50126e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000777394, Final residual = 9.45711e-06, No Iterations 6
ExecutionTime = 36.61 s ClockTime = 37 s
Time = 3.52
Courant Number mean: 0.115422 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000325481, Final residual = 9.21848e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000748644, Final residual = 5.39129e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00215993, Final residual = 0.00012878, No Iterations 7
time step continuity errors : sum local = 2.59054e-08, global = 1.57772e-09, cumulative = 6.24997e-06
GAMG: Solving for p, Initial residual = 0.000918906, Final residual = 5.76461e-07, No Iterations 23
time step continuity errors : sum local = 1.15605e-10, global = -5.96677e-12, cumulative = 6.24996e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000684177, Final residual = 6.50423e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000774289, Final residual = 9.47986e-06, No Iterations 6
ExecutionTime = 36.64 s ClockTime = 37 s
Time = 3.5225
Courant Number mean: 0.115395 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000323099, Final residual = 9.1908e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000743042, Final residual = 5.38858e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00193447, Final residual = 0.000128883, No Iterations 7
time step continuity errors : sum local = 2.59173e-08, global = 1.59109e-09, cumulative = 6.25156e-06
GAMG: Solving for p, Initial residual = 0.000906617, Final residual = 5.75178e-07, No Iterations 23
time step continuity errors : sum local = 1.15291e-10, global = -5.94367e-12, cumulative = 6.25155e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000681036, Final residual = 6.50836e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000771082, Final residual = 9.49787e-06, No Iterations 6
ExecutionTime = 36.67 s ClockTime = 37 s
Time = 3.525
Courant Number mean: 0.115367 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.00032071, Final residual = 9.16298e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000737283, Final residual = 5.38518e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00204142, Final residual = 0.000128318, No Iterations 7
time step continuity errors : sum local = 2.57926e-08, global = 1.56714e-09, cumulative = 6.25312e-06
GAMG: Solving for p, Initial residual = 0.000918619, Final residual = 5.7439e-07, No Iterations 23
time step continuity errors : sum local = 1.15093e-10, global = -5.93224e-12, cumulative = 6.25311e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000677909, Final residual = 6.50917e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00076796, Final residual = 9.51663e-06, No Iterations 6
ExecutionTime = 36.7 s ClockTime = 37 s
Time = 3.5275
Courant Number mean: 0.11534 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000318317, Final residual = 9.13468e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000731879, Final residual = 5.38297e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00179695, Final residual = 0.000128481, No Iterations 7
time step continuity errors : sum local = 2.58158e-08, global = 1.59356e-09, cumulative = 6.2547e-06
GAMG: Solving for p, Initial residual = 0.00089186, Final residual = 5.74188e-07, No Iterations 23
time step continuity errors : sum local = 1.15009e-10, global = -5.92637e-12, cumulative = 6.2547e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000674753, Final residual = 6.51314e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000764872, Final residual = 9.53526e-06, No Iterations 6
ExecutionTime = 36.73 s ClockTime = 37 s
Time = 3.53
Courant Number mean: 0.115312 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000315942, Final residual = 9.10559e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000726194, Final residual = 5.3781e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00188422, Final residual = 0.000128149, No Iterations 7
time step continuity errors : sum local = 2.57364e-08, global = 1.58867e-09, cumulative = 6.25629e-06
GAMG: Solving for p, Initial residual = 0.000902473, Final residual = 5.72159e-07, No Iterations 23
time step continuity errors : sum local = 1.14534e-10, global = -5.89165e-12, cumulative = 6.25628e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000671589, Final residual = 6.50959e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000761777, Final residual = 9.55334e-06, No Iterations 6
ExecutionTime = 36.76 s ClockTime = 37 s
Time = 3.5325
Courant Number mean: 0.115285 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000313577, Final residual = 9.0756e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000720468, Final residual = 5.37351e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00193215, Final residual = 0.000127881, No Iterations 7
time step continuity errors : sum local = 2.56667e-08, global = 1.58764e-09, cumulative = 6.25787e-06
GAMG: Solving for p, Initial residual = 0.000906702, Final residual = 5.73836e-07, No Iterations 23
time step continuity errors : sum local = 1.14801e-10, global = -5.91329e-12, cumulative = 6.25786e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000668446, Final residual = 6.50663e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000758641, Final residual = 9.57149e-06, No Iterations 6
ExecutionTime = 36.8 s ClockTime = 37 s
Time = 3.535
Courant Number mean: 0.115258 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000311221, Final residual = 9.04491e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000714579, Final residual = 5.36763e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.0019576, Final residual = 0.00012737, No Iterations 7
time step continuity errors : sum local = 2.55496e-08, global = 1.58932e-09, cumulative = 6.25945e-06
GAMG: Solving for p, Initial residual = 0.000909863, Final residual = 5.73378e-07, No Iterations 23
time step continuity errors : sum local = 1.14644e-10, global = -5.90836e-12, cumulative = 6.25945e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000665275, Final residual = 6.50467e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000755513, Final residual = 9.58766e-06, No Iterations 6
ExecutionTime = 36.83 s ClockTime = 37 s
Time = 3.5375
Courant Number mean: 0.115231 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000308898, Final residual = 9.01337e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000708939, Final residual = 5.3604e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00189489, Final residual = 0.000127006, No Iterations 7
time step continuity errors : sum local = 2.54644e-08, global = 1.58447e-09, cumulative = 6.26103e-06
GAMG: Solving for p, Initial residual = 0.000893846, Final residual = 5.73284e-07, No Iterations 23
time step continuity errors : sum local = 1.14585e-10, global = -5.90482e-12, cumulative = 6.26103e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000662038, Final residual = 6.50292e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000752382, Final residual = 9.6003e-06, No Iterations 6
ExecutionTime = 36.87 s ClockTime = 37 s
Time = 3.54
Courant Number mean: 0.115205 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000306568, Final residual = 8.98087e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000703398, Final residual = 5.35155e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00181906, Final residual = 0.000126921, No Iterations 7
time step continuity errors : sum local = 2.54382e-08, global = 1.5882e-09, cumulative = 6.26261e-06
GAMG: Solving for p, Initial residual = 0.000886589, Final residual = 5.7263e-07, No Iterations 23
time step continuity errors : sum local = 1.14413e-10, global = -5.89005e-12, cumulative = 6.26261e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000658759, Final residual = 6.49651e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000749317, Final residual = 9.61649e-06, No Iterations 6
ExecutionTime = 36.9 s ClockTime = 37 s
Time = 3.5425
Courant Number mean: 0.115178 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000304253, Final residual = 8.94795e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000697717, Final residual = 5.3419e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00184379, Final residual = 0.000127485, No Iterations 7
time step continuity errors : sum local = 2.55409e-08, global = 1.60555e-09, cumulative = 6.26421e-06
GAMG: Solving for p, Initial residual = 0.000886031, Final residual = 5.72004e-07, No Iterations 23
time step continuity errors : sum local = 1.14242e-10, global = -5.88302e-12, cumulative = 6.26421e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000655568, Final residual = 6.49548e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000746404, Final residual = 9.62784e-06, No Iterations 6
ExecutionTime = 36.93 s ClockTime = 37 s
Time = 3.545
Courant Number mean: 0.115152 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000301927, Final residual = 8.91444e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000692182, Final residual = 5.33217e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00189754, Final residual = 0.000125581, No Iterations 7
time step continuity errors : sum local = 2.51469e-08, global = 1.56415e-09, cumulative = 6.26577e-06
GAMG: Solving for p, Initial residual = 0.000900462, Final residual = 5.71348e-07, No Iterations 23
time step continuity errors : sum local = 1.14042e-10, global = -5.8729e-12, cumulative = 6.26577e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000652384, Final residual = 6.49191e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000743481, Final residual = 9.64153e-06, No Iterations 6
ExecutionTime = 36.95 s ClockTime = 37 s
Time = 3.5475
Courant Number mean: 0.115126 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000299592, Final residual = 8.87938e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000686561, Final residual = 5.32124e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00191277, Final residual = 0.000126015, No Iterations 7
time step continuity errors : sum local = 2.52187e-08, global = 1.57672e-09, cumulative = 6.26734e-06
GAMG: Solving for p, Initial residual = 0.000902745, Final residual = 5.70747e-07, No Iterations 23
time step continuity errors : sum local = 1.13861e-10, global = -5.86324e-12, cumulative = 6.26734e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000649293, Final residual = 6.49048e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000740584, Final residual = 9.65551e-06, No Iterations 6
ExecutionTime = 36.98 s ClockTime = 37 s
Time = 3.55
Courant Number mean: 0.1151 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000297264, Final residual = 8.8445e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000680994, Final residual = 5.30912e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00179008, Final residual = 0.000125751, No Iterations 7
time step continuity errors : sum local = 2.51536e-08, global = 1.58112e-09, cumulative = 6.26892e-06
GAMG: Solving for p, Initial residual = 0.000885903, Final residual = 5.70501e-07, No Iterations 23
time step continuity errors : sum local = 1.13759e-10, global = -5.86345e-12, cumulative = 6.26891e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000646157, Final residual = 6.48703e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000737599, Final residual = 9.66443e-06, No Iterations 6
ExecutionTime = 37.01 s ClockTime = 37 s
Time = 3.5525
Courant Number mean: 0.115074 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000294936, Final residual = 8.80834e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000675331, Final residual = 5.29569e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.0017523, Final residual = 0.000124979, No Iterations 7
time step continuity errors : sum local = 2.49882e-08, global = 1.57349e-09, cumulative = 6.27049e-06
GAMG: Solving for p, Initial residual = 0.000881071, Final residual = 5.69502e-07, No Iterations 23
time step continuity errors : sum local = 1.13512e-10, global = -5.85089e-12, cumulative = 6.27048e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000643102, Final residual = 6.4782e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000734535, Final residual = 9.67334e-06, No Iterations 6
ExecutionTime = 37.04 s ClockTime = 37 s
Time = 3.555
Courant Number mean: 0.115048 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000292626, Final residual = 8.77154e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00066965, Final residual = 9.99694e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00179123, Final residual = 0.000121792, No Iterations 7
time step continuity errors : sum local = 2.43417e-08, global = 1.36073e-09, cumulative = 6.27184e-06
GAMG: Solving for p, Initial residual = 0.000871859, Final residual = 9.82633e-07, No Iterations 21
time step continuity errors : sum local = 1.95784e-10, global = -9.393e-12, cumulative = 6.27183e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000639981, Final residual = 6.47031e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000731393, Final residual = 9.68053e-06, No Iterations 6
ExecutionTime = 37.07 s ClockTime = 37 s
Time = 3.5575
Courant Number mean: 0.115023 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000290268, Final residual = 8.73189e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000664838, Final residual = 5.28829e-06, No Iterations 6
GAMG: Solving for p, Initial residual = 0.00182629, Final residual = 0.00012431, No Iterations 7
time step continuity errors : sum local = 2.48387e-08, global = 1.58073e-09, cumulative = 6.27341e-06
GAMG: Solving for p, Initial residual = 0.00087574, Final residual = 5.71072e-07, No Iterations 23
time step continuity errors : sum local = 1.13761e-10, global = -5.87268e-12, cumulative = 6.27341e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000636807, Final residual = 6.46461e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000728236, Final residual = 9.68875e-06, No Iterations 6
ExecutionTime = 37.12 s ClockTime = 37 s
Time = 3.56
Courant Number mean: 0.114998 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000288079, Final residual = 8.69753e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000658503, Final residual = 9.90903e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00175539, Final residual = 0.000121501, No Iterations 7
time step continuity errors : sum local = 2.42684e-08, global = 1.3745e-09, cumulative = 6.27478e-06
GAMG: Solving for p, Initial residual = 0.000867292, Final residual = 9.79006e-07, No Iterations 21
time step continuity errors : sum local = 1.94945e-10, global = -9.33762e-12, cumulative = 6.27477e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000633635, Final residual = 6.45807e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000725162, Final residual = 9.69762e-06, No Iterations 6
ExecutionTime = 37.15 s ClockTime = 37 s
Time = 3.5625
Courant Number mean: 0.114972 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.0002857, Final residual = 8.65436e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000653732, Final residual = 9.93057e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00179016, Final residual = 0.000121165, No Iterations 7
time step continuity errors : sum local = 2.41901e-08, global = 1.35375e-09, cumulative = 6.27612e-06
GAMG: Solving for p, Initial residual = 0.0008569, Final residual = 9.84807e-07, No Iterations 21
time step continuity errors : sum local = 1.9597e-10, global = -9.42742e-12, cumulative = 6.27612e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00063047, Final residual = 6.45573e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00072207, Final residual = 9.70444e-06, No Iterations 6
ExecutionTime = 37.18 s ClockTime = 37 s
Time = 3.565
Courant Number mean: 0.114947 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000283465, Final residual = 8.61737e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000647909, Final residual = 9.87912e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00190126, Final residual = 0.000119578, No Iterations 7
time step continuity errors : sum local = 2.38577e-08, global = 1.34275e-09, cumulative = 6.27746e-06
GAMG: Solving for p, Initial residual = 0.000867074, Final residual = 9.82957e-07, No Iterations 21
time step continuity errors : sum local = 1.95488e-10, global = -9.39922e-12, cumulative = 6.27745e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000627281, Final residual = 6.44561e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000719064, Final residual = 9.71274e-06, No Iterations 6
ExecutionTime = 37.21 s ClockTime = 37 s
Time = 3.5675
Courant Number mean: 0.114922 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000281159, Final residual = 8.57558e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000642399, Final residual = 9.86092e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00189913, Final residual = 0.000119892, No Iterations 7
time step continuity errors : sum local = 2.39081e-08, global = 1.34938e-09, cumulative = 6.2788e-06
GAMG: Solving for p, Initial residual = 0.00086705, Final residual = 9.82358e-07, No Iterations 21
time step continuity errors : sum local = 1.95282e-10, global = -9.39716e-12, cumulative = 6.27879e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00062407, Final residual = 6.43634e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000716072, Final residual = 9.71591e-06, No Iterations 6
ExecutionTime = 37.24 s ClockTime = 37 s
Time = 3.57
Courant Number mean: 0.114897 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000278891, Final residual = 8.53518e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000636657, Final residual = 9.83116e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00174341, Final residual = 0.000119733, No Iterations 7
time step continuity errors : sum local = 2.3866e-08, global = 1.34902e-09, cumulative = 6.28014e-06
GAMG: Solving for p, Initial residual = 0.000849299, Final residual = 9.8046e-07, No Iterations 21
time step continuity errors : sum local = 1.94824e-10, global = -9.39029e-12, cumulative = 6.28013e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000620909, Final residual = 6.4301e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000713043, Final residual = 9.72014e-06, No Iterations 6
ExecutionTime = 37.27 s ClockTime = 38 s
Time = 3.5725
Courant Number mean: 0.114872 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000276614, Final residual = 8.49303e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000631089, Final residual = 9.80729e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00167158, Final residual = 0.000119315, No Iterations 7
time step continuity errors : sum local = 2.3773e-08, global = 1.34569e-09, cumulative = 6.28147e-06
GAMG: Solving for p, Initial residual = 0.000841268, Final residual = 9.78982e-07, No Iterations 21
time step continuity errors : sum local = 1.9446e-10, global = -9.36637e-12, cumulative = 6.28146e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000617695, Final residual = 6.41968e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000710033, Final residual = 9.72302e-06, No Iterations 6
ExecutionTime = 37.3 s ClockTime = 38 s
Time = 3.575
Courant Number mean: 0.114848 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000274367, Final residual = 8.45067e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0006256, Final residual = 9.78052e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00163998, Final residual = 0.000119143, No Iterations 7
time step continuity errors : sum local = 2.37288e-08, global = 1.34975e-09, cumulative = 6.28281e-06
GAMG: Solving for p, Initial residual = 0.000837555, Final residual = 9.76803e-07, No Iterations 21
time step continuity errors : sum local = 1.93938e-10, global = -9.34847e-12, cumulative = 6.2828e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000614489, Final residual = 6.4124e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000707056, Final residual = 9.7298e-06, No Iterations 6
ExecutionTime = 37.33 s ClockTime = 38 s
Time = 3.5775
Courant Number mean: 0.114823 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000272131, Final residual = 8.40805e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000620215, Final residual = 9.75483e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00187238, Final residual = 0.000117829, No Iterations 7
time step continuity errors : sum local = 2.34564e-08, global = 1.33085e-09, cumulative = 6.28414e-06
GAMG: Solving for p, Initial residual = 0.000854541, Final residual = 9.77196e-07, No Iterations 21
time step continuity errors : sum local = 1.93929e-10, global = -9.36436e-12, cumulative = 6.28413e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000611372, Final residual = 6.40162e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000704151, Final residual = 9.72906e-06, No Iterations 6
ExecutionTime = 37.35 s ClockTime = 38 s
Time = 3.58
Courant Number mean: 0.114799 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000269884, Final residual = 8.36416e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000614861, Final residual = 9.72885e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00168676, Final residual = 0.000119205, No Iterations 7
time step continuity errors : sum local = 2.37168e-08, global = 1.3495e-09, cumulative = 6.28548e-06
GAMG: Solving for p, Initial residual = 0.000838913, Final residual = 9.73539e-07, No Iterations 21
time step continuity errors : sum local = 1.9308e-10, global = -9.29956e-12, cumulative = 6.28547e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000608256, Final residual = 6.39007e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000701164, Final residual = 9.72922e-06, No Iterations 6
ExecutionTime = 37.39 s ClockTime = 38 s
Time = 3.5825
Courant Number mean: 0.114775 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000267647, Final residual = 8.32058e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000609416, Final residual = 9.70254e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00164177, Final residual = 0.000118013, No Iterations 7
time step continuity errors : sum local = 2.34656e-08, global = 1.33255e-09, cumulative = 6.2868e-06
GAMG: Solving for p, Initial residual = 0.000834935, Final residual = 9.70876e-07, No Iterations 21
time step continuity errors : sum local = 1.92451e-10, global = -9.29304e-12, cumulative = 6.28679e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00060513, Final residual = 6.37809e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000698223, Final residual = 9.72815e-06, No Iterations 6
ExecutionTime = 37.42 s ClockTime = 38 s
Time = 3.585
Courant Number mean: 0.114751 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000265408, Final residual = 8.2755e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000603966, Final residual = 9.6751e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00166634, Final residual = 0.000116611, No Iterations 7
time step continuity errors : sum local = 2.31737e-08, global = 1.3158e-09, cumulative = 6.28811e-06
GAMG: Solving for p, Initial residual = 0.000836222, Final residual = 9.70431e-07, No Iterations 21
time step continuity errors : sum local = 1.92248e-10, global = -9.27338e-12, cumulative = 6.2881e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000602006, Final residual = 6.36796e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000695191, Final residual = 9.72772e-06, No Iterations 6
ExecutionTime = 37.45 s ClockTime = 38 s
Time = 3.5875
Courant Number mean: 0.114727 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000263169, Final residual = 8.22942e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000598928, Final residual = 9.64569e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.001822, Final residual = 0.000116202, No Iterations 7
time step continuity errors : sum local = 2.30788e-08, global = 1.31866e-09, cumulative = 6.28941e-06
GAMG: Solving for p, Initial residual = 0.000859779, Final residual = 9.69515e-07, No Iterations 21
time step continuity errors : sum local = 1.91956e-10, global = -9.27428e-12, cumulative = 6.28941e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000598969, Final residual = 6.35916e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000692144, Final residual = 9.72686e-06, No Iterations 6
ExecutionTime = 37.48 s ClockTime = 38 s
Time = 3.59
Courant Number mean: 0.114703 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000260949, Final residual = 8.18275e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000593387, Final residual = 9.61548e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00165009, Final residual = 0.000115467, No Iterations 7
time step continuity errors : sum local = 2.29201e-08, global = 1.29991e-09, cumulative = 6.29071e-06
GAMG: Solving for p, Initial residual = 0.000834898, Final residual = 9.6733e-07, No Iterations 21
time step continuity errors : sum local = 1.91431e-10, global = -9.24788e-12, cumulative = 6.2907e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0005958, Final residual = 6.34653e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000689033, Final residual = 9.72647e-06, No Iterations 6
ExecutionTime = 37.51 s ClockTime = 38 s
Time = 3.5925
Courant Number mean: 0.114679 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000258774, Final residual = 8.13551e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000588064, Final residual = 9.58476e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00161886, Final residual = 0.000115127, No Iterations 7
time step continuity errors : sum local = 2.28418e-08, global = 1.296e-09, cumulative = 6.29199e-06
GAMG: Solving for p, Initial residual = 0.000828694, Final residual = 9.64932e-07, No Iterations 21
time step continuity errors : sum local = 1.90863e-10, global = -9.22324e-12, cumulative = 6.29198e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000592657, Final residual = 6.33586e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000686056, Final residual = 9.72113e-06, No Iterations 6
ExecutionTime = 37.54 s ClockTime = 38 s
Time = 3.595
Courant Number mean: 0.114655 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000256606, Final residual = 8.08803e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000582987, Final residual = 9.55242e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00151812, Final residual = 0.000114951, No Iterations 7
time step continuity errors : sum local = 2.27963e-08, global = 1.30516e-09, cumulative = 6.29329e-06
GAMG: Solving for p, Initial residual = 0.000812757, Final residual = 9.60901e-07, No Iterations 21
time step continuity errors : sum local = 1.8999e-10, global = -9.18935e-12, cumulative = 6.29328e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000589499, Final residual = 6.32166e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000683073, Final residual = 9.71684e-06, No Iterations 6
ExecutionTime = 37.57 s ClockTime = 38 s
Time = 3.5975
Courant Number mean: 0.114632 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000254449, Final residual = 8.0397e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000577738, Final residual = 9.51772e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00154151, Final residual = 0.00011415, No Iterations 7
time step continuity errors : sum local = 2.26291e-08, global = 1.29376e-09, cumulative = 6.29457e-06
GAMG: Solving for p, Initial residual = 0.00080775, Final residual = 9.57476e-07, No Iterations 21
time step continuity errors : sum local = 1.89259e-10, global = -9.16533e-12, cumulative = 6.29456e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000586397, Final residual = 6.30678e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000680149, Final residual = 9.71081e-06, No Iterations 6
ExecutionTime = 37.6 s ClockTime = 38 s
Time = 3.6
Courant Number mean: 0.114609 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000252283, Final residual = 7.99072e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000572423, Final residual = 9.48182e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00156713, Final residual = 0.000114042, No Iterations 7
time step continuity errors : sum local = 2.2601e-08, global = 1.29846e-09, cumulative = 6.29586e-06
GAMG: Solving for p, Initial residual = 0.000810527, Final residual = 9.55787e-07, No Iterations 21
time step continuity errors : sum local = 1.88875e-10, global = -9.16205e-12, cumulative = 6.29585e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000583261, Final residual = 6.2922e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000677243, Final residual = 9.70348e-06, No Iterations 6
ExecutionTime = 37.65 s ClockTime = 38 s
Time = 3.6025
Courant Number mean: 0.114585 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000250121, Final residual = 7.94094e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000567206, Final residual = 9.44652e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00149971, Final residual = 0.000113271, No Iterations 7
time step continuity errors : sum local = 2.24425e-08, global = 1.29015e-09, cumulative = 6.29714e-06
GAMG: Solving for p, Initial residual = 0.000797514, Final residual = 9.51513e-07, No Iterations 21
time step continuity errors : sum local = 1.87984e-10, global = -9.13107e-12, cumulative = 6.29713e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000580113, Final residual = 6.27909e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000674324, Final residual = 9.69393e-06, No Iterations 6
ExecutionTime = 37.67 s ClockTime = 38 s
Time = 3.605
Courant Number mean: 0.114562 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000247961, Final residual = 7.89063e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000562054, Final residual = 9.41697e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00144874, Final residual = 0.000112253, No Iterations 7
time step continuity errors : sum local = 2.22341e-08, global = 1.28214e-09, cumulative = 6.29842e-06
GAMG: Solving for p, Initial residual = 0.000793116, Final residual = 9.48264e-07, No Iterations 21
time step continuity errors : sum local = 1.87287e-10, global = -9.1031e-12, cumulative = 6.29841e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000577021, Final residual = 6.26533e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000671352, Final residual = 9.68599e-06, No Iterations 6
ExecutionTime = 37.7 s ClockTime = 38 s
Time = 3.6075
Courant Number mean: 0.114539 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000245797, Final residual = 7.8396e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000556828, Final residual = 9.39098e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00158602, Final residual = 0.000111717, No Iterations 7
time step continuity errors : sum local = 2.21215e-08, global = 1.28413e-09, cumulative = 6.29969e-06
GAMG: Solving for p, Initial residual = 0.000800746, Final residual = 9.46526e-07, No Iterations 21
time step continuity errors : sum local = 1.86893e-10, global = -9.10664e-12, cumulative = 6.29968e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000573956, Final residual = 6.24881e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000668372, Final residual = 9.67869e-06, No Iterations 6
ExecutionTime = 37.73 s ClockTime = 38 s
Time = 3.61
Courant Number mean: 0.114517 max: 0.616697
smoothSolver: Solving for Ux, Initial residual = 0.000243649, Final residual = 7.78815e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.0005519, Final residual = 9.36801e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00175616, Final residual = 0.000110019, No Iterations 7
time step continuity errors : sum local = 2.17777e-08, global = 1.285e-09, cumulative = 6.30097e-06
GAMG: Solving for p, Initial residual = 0.000825366, Final residual = 9.45898e-07, No Iterations 21
time step continuity errors : sum local = 1.86692e-10, global = -9.11946e-12, cumulative = 6.30096e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000570902, Final residual = 6.23218e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000665441, Final residual = 9.66826e-06, No Iterations 6
ExecutionTime = 37.76 s ClockTime = 38 s
Time = 3.6125
Courant Number mean: 0.114494 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000241516, Final residual = 7.73642e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000546558, Final residual = 9.34629e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00153795, Final residual = 0.000109926, No Iterations 7
time step continuity errors : sum local = 2.17515e-08, global = 1.26613e-09, cumulative = 6.30222e-06
GAMG: Solving for p, Initial residual = 0.000793532, Final residual = 9.40791e-07, No Iterations 21
time step continuity errors : sum local = 1.85642e-10, global = -9.06153e-12, cumulative = 6.30221e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000567849, Final residual = 6.21737e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000662435, Final residual = 9.65337e-06, No Iterations 6
ExecutionTime = 37.79 s ClockTime = 38 s
Time = 3.615
Courant Number mean: 0.114472 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.0002394, Final residual = 7.6838e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000541646, Final residual = 9.3251e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00136906, Final residual = 0.000109708, No Iterations 7
time step continuity errors : sum local = 2.17028e-08, global = 1.25888e-09, cumulative = 6.30347e-06
GAMG: Solving for p, Initial residual = 0.000773396, Final residual = 9.35721e-07, No Iterations 21
time step continuity errors : sum local = 1.84594e-10, global = -9.02429e-12, cumulative = 6.30346e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00056482, Final residual = 6.20353e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000659458, Final residual = 9.64058e-06, No Iterations 6
ExecutionTime = 37.82 s ClockTime = 38 s
Time = 3.6175
Courant Number mean: 0.114449 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.00023731, Final residual = 7.63084e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000536603, Final residual = 9.30413e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00135475, Final residual = 0.000108859, No Iterations 7
time step continuity errors : sum local = 2.15288e-08, global = 1.25115e-09, cumulative = 6.30472e-06
GAMG: Solving for p, Initial residual = 0.000770447, Final residual = 9.31592e-07, No Iterations 21
time step continuity errors : sum local = 1.83733e-10, global = -8.99744e-12, cumulative = 6.30471e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000561747, Final residual = 6.18491e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000656572, Final residual = 9.62744e-06, No Iterations 6
ExecutionTime = 37.84 s ClockTime = 38 s
Time = 3.62
Courant Number mean: 0.114427 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000235223, Final residual = 7.57756e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000531574, Final residual = 9.2835e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00136578, Final residual = 0.000108213, No Iterations 7
time step continuity errors : sum local = 2.13956e-08, global = 1.24622e-09, cumulative = 6.30595e-06
GAMG: Solving for p, Initial residual = 0.000768076, Final residual = 9.28595e-07, No Iterations 21
time step continuity errors : sum local = 1.83099e-10, global = -8.98466e-12, cumulative = 6.30594e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000558714, Final residual = 6.16578e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00065373, Final residual = 9.61439e-06, No Iterations 6
ExecutionTime = 37.88 s ClockTime = 38 s
Time = 3.6225
Courant Number mean: 0.114405 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000233142, Final residual = 7.52339e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000526585, Final residual = 9.26327e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00138534, Final residual = 0.000107352, No Iterations 7
time step continuity errors : sum local = 2.12194e-08, global = 1.23472e-09, cumulative = 6.30718e-06
GAMG: Solving for p, Initial residual = 0.000766195, Final residual = 9.24497e-07, No Iterations 21
time step continuity errors : sum local = 1.82235e-10, global = -8.95588e-12, cumulative = 6.30717e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000555665, Final residual = 6.14688e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000650813, Final residual = 9.59956e-06, No Iterations 6
ExecutionTime = 37.9 s ClockTime = 38 s
Time = 3.625
Courant Number mean: 0.114383 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.00023106, Final residual = 7.46883e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000521676, Final residual = 9.24327e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00136331, Final residual = 0.000106946, No Iterations 7
time step continuity errors : sum local = 2.11321e-08, global = 1.23967e-09, cumulative = 6.30841e-06
GAMG: Solving for p, Initial residual = 0.00076059, Final residual = 9.20545e-07, No Iterations 21
time step continuity errors : sum local = 1.81402e-10, global = -8.9307e-12, cumulative = 6.3084e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00055257, Final residual = 6.12796e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000647834, Final residual = 9.58538e-06, No Iterations 6
ExecutionTime = 37.94 s ClockTime = 38 s
Time = 3.6275
Courant Number mean: 0.114361 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000228988, Final residual = 7.41391e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000516917, Final residual = 9.22287e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00135264, Final residual = 0.000105876, No Iterations 7
time step continuity errors : sum local = 2.09136e-08, global = 1.22909e-09, cumulative = 6.30963e-06
GAMG: Solving for p, Initial residual = 0.000757435, Final residual = 9.15912e-07, No Iterations 21
time step continuity errors : sum local = 1.80428e-10, global = -8.90345e-12, cumulative = 6.30962e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000549516, Final residual = 6.11257e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000644924, Final residual = 9.56857e-06, No Iterations 6
ExecutionTime = 37.96 s ClockTime = 38 s
Time = 3.63
Courant Number mean: 0.11434 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000226929, Final residual = 7.35795e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000512127, Final residual = 9.20171e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00156679, Final residual = 0.000105506, No Iterations 7
time step continuity errors : sum local = 2.08298e-08, global = 1.23331e-09, cumulative = 6.31085e-06
GAMG: Solving for p, Initial residual = 0.00077378, Final residual = 9.13459e-07, No Iterations 21
time step continuity errors : sum local = 1.79834e-10, global = -8.89264e-12, cumulative = 6.31085e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00054652, Final residual = 6.09433e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000641983, Final residual = 9.55031e-06, No Iterations 6
ExecutionTime = 37.99 s ClockTime = 38 s
Time = 3.6325
Courant Number mean: 0.114318 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000224875, Final residual = 7.30243e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000507395, Final residual = 9.18064e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00159251, Final residual = 0.000104713, No Iterations 7
time step continuity errors : sum local = 2.06626e-08, global = 1.22873e-09, cumulative = 6.31207e-06
GAMG: Solving for p, Initial residual = 0.000773101, Final residual = 9.10413e-07, No Iterations 21
time step continuity errors : sum local = 1.79162e-10, global = -8.88403e-12, cumulative = 6.31207e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000543608, Final residual = 6.07694e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000639048, Final residual = 9.53346e-06, No Iterations 6
ExecutionTime = 38.02 s ClockTime = 38 s
Time = 3.635
Courant Number mean: 0.114297 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000222833, Final residual = 7.2467e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000502637, Final residual = 9.15934e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0014389, Final residual = 0.000104002, No Iterations 7
time step continuity errors : sum local = 2.05145e-08, global = 1.22022e-09, cumulative = 6.31329e-06
GAMG: Solving for p, Initial residual = 0.000742003, Final residual = 9.0506e-07, No Iterations 21
time step continuity errors : sum local = 1.78059e-10, global = -8.84947e-12, cumulative = 6.31328e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000540736, Final residual = 6.0568e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000636123, Final residual = 9.51408e-06, No Iterations 6
ExecutionTime = 38.05 s ClockTime = 38 s
Time = 3.6375
Courant Number mean: 0.114276 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000220797, Final residual = 7.19056e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00049799, Final residual = 9.13753e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00135658, Final residual = 0.000102735, No Iterations 7
time step continuity errors : sum local = 2.02589e-08, global = 1.20175e-09, cumulative = 6.31448e-06
GAMG: Solving for p, Initial residual = 0.000734574, Final residual = 8.99402e-07, No Iterations 21
time step continuity errors : sum local = 1.76903e-10, global = -8.80825e-12, cumulative = 6.31447e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000537917, Final residual = 6.03482e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000633259, Final residual = 9.49297e-06, No Iterations 6
ExecutionTime = 38.08 s ClockTime = 38 s
Time = 3.64
Courant Number mean: 0.114255 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000218776, Final residual = 7.1338e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000493315, Final residual = 9.11564e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00138031, Final residual = 0.000101921, No Iterations 7
time step continuity errors : sum local = 2.00935e-08, global = 1.1997e-09, cumulative = 6.31567e-06
GAMG: Solving for p, Initial residual = 0.000734522, Final residual = 8.95275e-07, No Iterations 21
time step continuity errors : sum local = 1.7605e-10, global = -8.78672e-12, cumulative = 6.31566e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000535055, Final residual = 6.0155e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000630492, Final residual = 9.46973e-06, No Iterations 6
ExecutionTime = 38.11 s ClockTime = 38 s
Time = 3.6425
Courant Number mean: 0.114234 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000216768, Final residual = 7.07672e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000488676, Final residual = 9.09303e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00128133, Final residual = 0.000101082, No Iterations 7
time step continuity errors : sum local = 1.99225e-08, global = 1.18684e-09, cumulative = 6.31685e-06
GAMG: Solving for p, Initial residual = 0.0007219, Final residual = 8.89999e-07, No Iterations 21
time step continuity errors : sum local = 1.74965e-10, global = -8.75378e-12, cumulative = 6.31684e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00053224, Final residual = 5.99429e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000627676, Final residual = 9.44922e-06, No Iterations 6
ExecutionTime = 38.14 s ClockTime = 38 s
Time = 3.645
Courant Number mean: 0.114213 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000214764, Final residual = 7.01887e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000484048, Final residual = 9.06891e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00125935, Final residual = 0.000100428, No Iterations 7
time step continuity errors : sum local = 1.97875e-08, global = 1.18346e-09, cumulative = 6.31802e-06
GAMG: Solving for p, Initial residual = 0.000719044, Final residual = 8.85636e-07, No Iterations 21
time step continuity errors : sum local = 1.74053e-10, global = -8.72616e-12, cumulative = 6.31801e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000529359, Final residual = 5.97325e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000624898, Final residual = 9.42787e-06, No Iterations 6
ExecutionTime = 38.17 s ClockTime = 38 s
Time = 3.6475
Courant Number mean: 0.114193 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000212775, Final residual = 6.96083e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000479511, Final residual = 9.04505e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00129706, Final residual = 9.96282e-05, No Iterations 7
time step continuity errors : sum local = 1.96233e-08, global = 1.17811e-09, cumulative = 6.31919e-06
GAMG: Solving for p, Initial residual = 0.000718972, Final residual = 8.812e-07, No Iterations 21
time step continuity errors : sum local = 1.73126e-10, global = -8.70149e-12, cumulative = 6.31918e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000526467, Final residual = 5.95138e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000622095, Final residual = 9.40403e-06, No Iterations 6
ExecutionTime = 38.2 s ClockTime = 38 s
Time = 3.65
Courant Number mean: 0.114172 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000210806, Final residual = 6.90261e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000475043, Final residual = 9.02039e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00133258, Final residual = 9.87465e-05, No Iterations 7
time step continuity errors : sum local = 1.9443e-08, global = 1.17021e-09, cumulative = 6.32035e-06
GAMG: Solving for p, Initial residual = 0.000714666, Final residual = 8.76367e-07, No Iterations 21
time step continuity errors : sum local = 1.72122e-10, global = -8.67235e-12, cumulative = 6.32034e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000523591, Final residual = 5.93214e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000619222, Final residual = 9.37924e-06, No Iterations 6
ExecutionTime = 38.23 s ClockTime = 38 s
Time = 3.6525
Courant Number mean: 0.114152 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000208853, Final residual = 6.84416e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000470502, Final residual = 8.99515e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00138693, Final residual = 9.78192e-05, No Iterations 7
time step continuity errors : sum local = 1.92534e-08, global = 1.16016e-09, cumulative = 6.3215e-06
GAMG: Solving for p, Initial residual = 0.000715763, Final residual = 8.72823e-07, No Iterations 21
time step continuity errors : sum local = 1.7136e-10, global = -8.653e-12, cumulative = 6.3215e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000520661, Final residual = 5.91372e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00061632, Final residual = 9.35332e-06, No Iterations 6
ExecutionTime = 38.26 s ClockTime = 39 s
Time = 3.655
Courant Number mean: 0.114132 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000206912, Final residual = 6.78557e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000466076, Final residual = 8.96911e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00138542, Final residual = 9.66962e-05, No Iterations 7
time step continuity errors : sum local = 1.90254e-08, global = 1.14723e-09, cumulative = 6.32264e-06
GAMG: Solving for p, Initial residual = 0.000710296, Final residual = 8.6829e-07, No Iterations 21
time step continuity errors : sum local = 1.7042e-10, global = -8.63328e-12, cumulative = 6.32263e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000517729, Final residual = 5.89186e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000613448, Final residual = 9.32728e-06, No Iterations 6
ExecutionTime = 38.29 s ClockTime = 39 s
Time = 3.6575
Courant Number mean: 0.114112 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000204977, Final residual = 6.72684e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000461822, Final residual = 8.94247e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00127816, Final residual = 9.56434e-05, No Iterations 7
time step continuity errors : sum local = 1.88122e-08, global = 1.1363e-09, cumulative = 6.32377e-06
GAMG: Solving for p, Initial residual = 0.000696497, Final residual = 8.61112e-07, No Iterations 21
time step continuity errors : sum local = 1.68964e-10, global = -8.58301e-12, cumulative = 6.32376e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000514899, Final residual = 5.86872e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000610629, Final residual = 9.30121e-06, No Iterations 6
ExecutionTime = 38.31 s ClockTime = 39 s
Time = 3.66
Courant Number mean: 0.114092 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000203056, Final residual = 6.66785e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000457514, Final residual = 8.91432e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00149443, Final residual = 9.51531e-05, No Iterations 7
time step continuity errors : sum local = 1.87094e-08, global = 1.13109e-09, cumulative = 6.32489e-06
GAMG: Solving for p, Initial residual = 0.000713783, Final residual = 8.57158e-07, No Iterations 21
time step continuity errors : sum local = 1.68116e-10, global = -8.56031e-12, cumulative = 6.32488e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00051224, Final residual = 5.84435e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000607808, Final residual = 9.2721e-06, No Iterations 6
ExecutionTime = 38.34 s ClockTime = 39 s
Time = 3.6625
Courant Number mean: 0.114073 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000201151, Final residual = 6.60899e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000452945, Final residual = 8.88571e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00137941, Final residual = 9.4453e-05, No Iterations 7
time step continuity errors : sum local = 1.85645e-08, global = 1.1282e-09, cumulative = 6.32601e-06
GAMG: Solving for p, Initial residual = 0.000696574, Final residual = 8.52198e-07, No Iterations 21
time step continuity errors : sum local = 1.67099e-10, global = -8.53373e-12, cumulative = 6.326e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000509644, Final residual = 5.82427e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000605004, Final residual = 9.2449e-06, No Iterations 6
ExecutionTime = 38.37 s ClockTime = 39 s
Time = 3.665
Courant Number mean: 0.114054 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000199252, Final residual = 6.54967e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000448528, Final residual = 8.86094e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00129561, Final residual = 9.30749e-05, No Iterations 7
time step continuity errors : sum local = 1.82882e-08, global = 1.11287e-09, cumulative = 6.32712e-06
GAMG: Solving for p, Initial residual = 0.000682155, Final residual = 8.46191e-07, No Iterations 21
time step continuity errors : sum local = 1.65882e-10, global = -8.49409e-12, cumulative = 6.32711e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000507036, Final residual = 5.80043e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000602252, Final residual = 9.21632e-06, No Iterations 6
ExecutionTime = 38.39 s ClockTime = 39 s
Time = 3.6675
Courant Number mean: 0.114035 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000197359, Final residual = 6.48985e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000444225, Final residual = 8.84292e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00122136, Final residual = 9.17229e-05, No Iterations 7
time step continuity errors : sum local = 1.80178e-08, global = 1.09928e-09, cumulative = 6.32821e-06
GAMG: Solving for p, Initial residual = 0.000674344, Final residual = 8.40587e-07, No Iterations 21
time step continuity errors : sum local = 1.64737e-10, global = -8.46256e-12, cumulative = 6.3282e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00050442, Final residual = 5.77883e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000599549, Final residual = 9.1843e-06, No Iterations 6
ExecutionTime = 38.42 s ClockTime = 39 s
Time = 3.67
Courant Number mean: 0.114016 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000195493, Final residual = 6.42958e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000439968, Final residual = 8.82683e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00124542, Final residual = 9.0581e-05, No Iterations 7
time step continuity errors : sum local = 1.77877e-08, global = 1.08704e-09, cumulative = 6.32929e-06
GAMG: Solving for p, Initial residual = 0.000670054, Final residual = 8.35011e-07, No Iterations 21
time step continuity errors : sum local = 1.63596e-10, global = -8.43011e-12, cumulative = 6.32928e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000501769, Final residual = 5.75372e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000596857, Final residual = 9.15532e-06, No Iterations 6
ExecutionTime = 38.46 s ClockTime = 39 s
Time = 3.6725
Courant Number mean: 0.113997 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000193649, Final residual = 6.36923e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000435663, Final residual = 8.81274e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0012156, Final residual = 8.96025e-05, No Iterations 7
time step continuity errors : sum local = 1.7591e-08, global = 1.07544e-09, cumulative = 6.33035e-06
GAMG: Solving for p, Initial residual = 0.000666159, Final residual = 8.30353e-07, No Iterations 21
time step continuity errors : sum local = 1.62652e-10, global = -8.40803e-12, cumulative = 6.33034e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000499104, Final residual = 5.73279e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000594141, Final residual = 9.12035e-06, No Iterations 6
ExecutionTime = 38.49 s ClockTime = 39 s
Time = 3.675
Courant Number mean: 0.113978 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000191822, Final residual = 6.30951e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000431468, Final residual = 8.80027e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00133936, Final residual = 8.84397e-05, No Iterations 7
time step continuity errors : sum local = 1.73588e-08, global = 1.06251e-09, cumulative = 6.33141e-06
GAMG: Solving for p, Initial residual = 0.000669907, Final residual = 8.25501e-07, No Iterations 21
time step continuity errors : sum local = 1.61667e-10, global = -8.38803e-12, cumulative = 6.3314e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000496458, Final residual = 5.70824e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000591411, Final residual = 9.08702e-06, No Iterations 6
ExecutionTime = 38.52 s ClockTime = 39 s
Time = 3.6775
Courant Number mean: 0.11396 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000190008, Final residual = 6.24984e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000427439, Final residual = 8.78925e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00131064, Final residual = 8.73415e-05, No Iterations 7
time step continuity errors : sum local = 1.71394e-08, global = 1.04915e-09, cumulative = 6.33245e-06
GAMG: Solving for p, Initial residual = 0.000654616, Final residual = 8.18473e-07, No Iterations 21
time step continuity errors : sum local = 1.60258e-10, global = -8.34906e-12, cumulative = 6.33244e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000493779, Final residual = 5.68452e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000588754, Final residual = 9.05182e-06, No Iterations 6
ExecutionTime = 38.54 s ClockTime = 39 s
Time = 3.68
Courant Number mean: 0.113942 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000188202, Final residual = 6.18977e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000423342, Final residual = 8.77852e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00125574, Final residual = 8.63173e-05, No Iterations 7
time step continuity errors : sum local = 1.69344e-08, global = 1.0395e-09, cumulative = 6.33348e-06
GAMG: Solving for p, Initial residual = 0.000644621, Final residual = 8.1311e-07, No Iterations 21
time step continuity errors : sum local = 1.59174e-10, global = -8.32361e-12, cumulative = 6.33347e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000491203, Final residual = 5.65801e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000586079, Final residual = 9.01656e-06, No Iterations 6
ExecutionTime = 38.57 s ClockTime = 39 s
Time = 3.6825
Courant Number mean: 0.113924 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000186413, Final residual = 6.12948e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00041929, Final residual = 8.76834e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00125896, Final residual = 8.51586e-05, No Iterations 7
time step continuity errors : sum local = 1.67025e-08, global = 1.03055e-09, cumulative = 6.3345e-06
GAMG: Solving for p, Initial residual = 0.000637911, Final residual = 8.07616e-07, No Iterations 21
time step continuity errors : sum local = 1.58053e-10, global = -8.29045e-12, cumulative = 6.33449e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000488673, Final residual = 5.63563e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000583375, Final residual = 8.98344e-06, No Iterations 6
ExecutionTime = 38.6 s ClockTime = 39 s
Time = 3.685
Courant Number mean: 0.113906 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000184629, Final residual = 6.06933e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000415279, Final residual = 8.75815e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00122307, Final residual = 8.40107e-05, No Iterations 7
time step continuity errors : sum local = 1.64724e-08, global = 1.01843e-09, cumulative = 6.33551e-06
GAMG: Solving for p, Initial residual = 0.000633454, Final residual = 8.01952e-07, No Iterations 21
time step continuity errors : sum local = 1.56905e-10, global = -8.26667e-12, cumulative = 6.3355e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000486154, Final residual = 5.61257e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000580682, Final residual = 8.94779e-06, No Iterations 6
ExecutionTime = 38.62 s ClockTime = 39 s
Time = 3.6875
Courant Number mean: 0.113888 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000182857, Final residual = 6.00928e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000411368, Final residual = 8.74868e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00123546, Final residual = 8.26718e-05, No Iterations 7
time step continuity errors : sum local = 1.62047e-08, global = 1.00534e-09, cumulative = 6.33651e-06
GAMG: Solving for p, Initial residual = 0.000629355, Final residual = 7.97324e-07, No Iterations 21
time step continuity errors : sum local = 1.55949e-10, global = -8.25065e-12, cumulative = 6.3365e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000483748, Final residual = 5.58667e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000577964, Final residual = 8.90783e-06, No Iterations 6
ExecutionTime = 38.65 s ClockTime = 39 s
Time = 3.69
Courant Number mean: 0.113871 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000181099, Final residual = 5.94943e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000407519, Final residual = 8.73958e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00126131, Final residual = 8.13433e-05, No Iterations 7
time step continuity errors : sum local = 1.59386e-08, global = 9.93195e-10, cumulative = 6.33749e-06
GAMG: Solving for p, Initial residual = 0.000624035, Final residual = 7.91411e-07, No Iterations 21
time step continuity errors : sum local = 1.54736e-10, global = -8.21927e-12, cumulative = 6.33749e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000481349, Final residual = 5.56164e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000575294, Final residual = 8.87015e-06, No Iterations 6
ExecutionTime = 38.68 s ClockTime = 39 s
Time = 3.6925
Courant Number mean: 0.113853 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000179352, Final residual = 5.88984e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000403719, Final residual = 8.72991e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00121321, Final residual = 8.01699e-05, No Iterations 7
time step continuity errors : sum local = 1.5701e-08, global = 9.79248e-10, cumulative = 6.33846e-06
GAMG: Solving for p, Initial residual = 0.000616812, Final residual = 7.85597e-07, No Iterations 21
time step continuity errors : sum local = 1.53521e-10, global = -8.19142e-12, cumulative = 6.33846e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000478955, Final residual = 5.53779e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000572626, Final residual = 8.83151e-06, No Iterations 6
ExecutionTime = 38.71 s ClockTime = 39 s
Time = 3.695
Courant Number mean: 0.113836 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000177621, Final residual = 5.83049e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000399923, Final residual = 8.71989e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00122839, Final residual = 7.92884e-05, No Iterations 7
time step continuity errors : sum local = 1.55215e-08, global = 9.74509e-10, cumulative = 6.33943e-06
GAMG: Solving for p, Initial residual = 0.000608216, Final residual = 7.79342e-07, No Iterations 21
time step continuity errors : sum local = 1.52238e-10, global = -8.16411e-12, cumulative = 6.33942e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000476552, Final residual = 5.51172e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000569965, Final residual = 8.79422e-06, No Iterations 6
ExecutionTime = 38.74 s ClockTime = 39 s
Time = 3.6975
Courant Number mean: 0.113819 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000175898, Final residual = 5.77109e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000396162, Final residual = 8.70858e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00119577, Final residual = 7.80034e-05, No Iterations 7
time step continuity errors : sum local = 1.52641e-08, global = 9.59623e-10, cumulative = 6.34038e-06
GAMG: Solving for p, Initial residual = 0.000601249, Final residual = 7.73761e-07, No Iterations 21
time step continuity errors : sum local = 1.51092e-10, global = -8.13476e-12, cumulative = 6.34037e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000474188, Final residual = 5.48493e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000567406, Final residual = 8.75245e-06, No Iterations 6
ExecutionTime = 38.77 s ClockTime = 39 s
Time = 3.7
Courant Number mean: 0.113802 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000174194, Final residual = 5.71177e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000392429, Final residual = 8.69758e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00118466, Final residual = 7.71329e-05, No Iterations 7
time step continuity errors : sum local = 1.50874e-08, global = 9.48988e-10, cumulative = 6.34132e-06
GAMG: Solving for p, Initial residual = 0.000595061, Final residual = 7.68407e-07, No Iterations 21
time step continuity errors : sum local = 1.49989e-10, global = -8.10669e-12, cumulative = 6.34132e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000471786, Final residual = 5.46182e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000564898, Final residual = 8.71314e-06, No Iterations 6
ExecutionTime = 38.82 s ClockTime = 39 s
Time = 3.7025
Courant Number mean: 0.113786 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000172507, Final residual = 5.65277e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000388791, Final residual = 8.68513e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00117668, Final residual = 7.62213e-05, No Iterations 7
time step continuity errors : sum local = 1.49028e-08, global = 9.40023e-10, cumulative = 6.34226e-06
GAMG: Solving for p, Initial residual = 0.000588569, Final residual = 7.6281e-07, No Iterations 21
time step continuity errors : sum local = 1.48839e-10, global = -8.07687e-12, cumulative = 6.34225e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000469421, Final residual = 5.43477e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000562375, Final residual = 8.6698e-06, No Iterations 6
ExecutionTime = 38.85 s ClockTime = 39 s
Time = 3.705
Courant Number mean: 0.11377 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000170832, Final residual = 5.59386e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000385181, Final residual = 8.6727e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00116487, Final residual = 7.54493e-05, No Iterations 7
time step continuity errors : sum local = 1.47456e-08, global = 9.32742e-10, cumulative = 6.34318e-06
GAMG: Solving for p, Initial residual = 0.000582804, Final residual = 7.57089e-07, No Iterations 21
time step continuity errors : sum local = 1.47664e-10, global = -8.0471e-12, cumulative = 6.34317e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000467069, Final residual = 5.40966e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000559851, Final residual = 8.62429e-06, No Iterations 6
ExecutionTime = 38.87 s ClockTime = 39 s
Time = 3.7075
Courant Number mean: 0.113753 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000169168, Final residual = 5.53517e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.00038157, Final residual = 8.65903e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00111577, Final residual = 7.43405e-05, No Iterations 7
time step continuity errors : sum local = 1.4523e-08, global = 9.23397e-10, cumulative = 6.3441e-06
GAMG: Solving for p, Initial residual = 0.000576412, Final residual = 7.51282e-07, No Iterations 21
time step continuity errors : sum local = 1.46478e-10, global = -8.01558e-12, cumulative = 6.34409e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000464734, Final residual = 5.38293e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000557334, Final residual = 8.58368e-06, No Iterations 6
ExecutionTime = 38.91 s ClockTime = 39 s
Time = 3.71
Courant Number mean: 0.113737 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000167513, Final residual = 5.4767e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000377961, Final residual = 8.64471e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00107884, Final residual = 7.32219e-05, No Iterations 7
time step continuity errors : sum local = 1.42992e-08, global = 9.11676e-10, cumulative = 6.345e-06
GAMG: Solving for p, Initial residual = 0.000569332, Final residual = 7.45227e-07, No Iterations 21
time step continuity errors : sum local = 1.45252e-10, global = -7.9801e-12, cumulative = 6.34499e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000462399, Final residual = 5.35695e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000554815, Final residual = 8.54095e-06, No Iterations 6
ExecutionTime = 38.94 s ClockTime = 39 s
Time = 3.7125
Courant Number mean: 0.113722 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000165885, Final residual = 9.90374e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00037436, Final residual = 8.62976e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00132736, Final residual = 9.06579e-05, No Iterations 9
time step continuity errors : sum local = 1.76966e-08, global = 6.78196e-10, cumulative = 6.34567e-06
GAMG: Solving for p, Initial residual = 0.000975536, Final residual = 7.6983e-07, No Iterations 23
time step continuity errors : sum local = 1.49456e-10, global = -8.6466e-12, cumulative = 6.34566e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000460025, Final residual = 5.3273e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000552272, Final residual = 8.49679e-06, No Iterations 6
ExecutionTime = 38.97 s ClockTime = 39 s
Time = 3.715
Courant Number mean: 0.113706 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000164931, Final residual = 5.48778e-06, No Iterations 4
smoothSolver: Solving for Uy, Initial residual = 0.000370744, Final residual = 8.57492e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00117751, Final residual = 0.000100887, No Iterations 5
time step continuity errors : sum local = 1.96671e-08, global = 2.59368e-09, cumulative = 6.34825e-06
GAMG: Solving for p, Initial residual = 0.000509903, Final residual = 6.98054e-07, No Iterations 21
time step continuity errors : sum local = 1.36104e-10, global = -8.04868e-12, cumulative = 6.34825e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000457719, Final residual = 5.30463e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000549701, Final residual = 8.44976e-06, No Iterations 6
ExecutionTime = 39 s ClockTime = 39 s
Time = 3.7175
Courant Number mean: 0.113691 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000162357, Final residual = 9.61166e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000367651, Final residual = 8.6716e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00127998, Final residual = 0.000101447, No Iterations 9
time step continuity errors : sum local = 1.98037e-08, global = 8.24178e-10, cumulative = 6.34907e-06
GAMG: Solving for p, Initial residual = 0.00102232, Final residual = 7.87523e-07, No Iterations 23
time step continuity errors : sum local = 1.52759e-10, global = -8.95315e-12, cumulative = 6.34906e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000455402, Final residual = 5.27933e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000547194, Final residual = 8.40509e-06, No Iterations 6
ExecutionTime = 39.03 s ClockTime = 39 s
Time = 3.72
Courant Number mean: 0.113676 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000161943, Final residual = 9.84147e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000363409, Final residual = 8.491e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00134666, Final residual = 0.000102914, No Iterations 7
time step continuity errors : sum local = 2.00445e-08, global = 1.45018e-09, cumulative = 6.35051e-06
GAMG: Solving for p, Initial residual = 0.000843087, Final residual = 6.24949e-07, No Iterations 23
time step continuity errors : sum local = 1.21459e-10, global = -7.1477e-12, cumulative = 6.3505e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000453131, Final residual = 5.2492e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000544721, Final residual = 8.36339e-06, No Iterations 6
ExecutionTime = 39.06 s ClockTime = 39 s
Time = 3.7225
Courant Number mean: 0.113661 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000159945, Final residual = 9.6214e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000360731, Final residual = 8.61662e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0012555, Final residual = 6.90489e-05, No Iterations 9
time step continuity errors : sum local = 1.34553e-08, global = 5.67923e-10, cumulative = 6.35107e-06
GAMG: Solving for p, Initial residual = 0.000860657, Final residual = 6.94289e-07, No Iterations 23
time step continuity errors : sum local = 1.34782e-10, global = -7.94919e-12, cumulative = 6.35106e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000450902, Final residual = 5.21918e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000542277, Final residual = 8.31578e-06, No Iterations 6
ExecutionTime = 39.09 s ClockTime = 39 s
Time = 3.725
Courant Number mean: 0.113646 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000158549, Final residual = 9.56829e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000357018, Final residual = 8.50287e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00125944, Final residual = 0.000117377, No Iterations 7
time step continuity errors : sum local = 2.2862e-08, global = 1.32649e-09, cumulative = 6.35239e-06
GAMG: Solving for p, Initial residual = 0.00084392, Final residual = 6.20719e-07, No Iterations 23
time step continuity errors : sum local = 1.20549e-10, global = -7.08065e-12, cumulative = 6.35238e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00044871, Final residual = 5.19037e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00053986, Final residual = 8.27012e-06, No Iterations 6
ExecutionTime = 39.13 s ClockTime = 39 s
Time = 3.7275
Courant Number mean: 0.113632 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000157032, Final residual = 9.46406e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000353546, Final residual = 8.53443e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00123462, Final residual = 0.000113923, No Iterations 7
time step continuity errors : sum local = 2.21844e-08, global = 1.27272e-09, cumulative = 6.35366e-06
GAMG: Solving for p, Initial residual = 0.000812049, Final residual = 6.05128e-07, No Iterations 23
time step continuity errors : sum local = 1.17501e-10, global = -6.96369e-12, cumulative = 6.35365e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000446544, Final residual = 5.16282e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000537543, Final residual = 8.2231e-06, No Iterations 6
ExecutionTime = 39.16 s ClockTime = 39 s
Time = 3.73
Courant Number mean: 0.113617 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000155569, Final residual = 9.38048e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000349995, Final residual = 8.4789e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00117776, Final residual = 0.000108623, No Iterations 7
time step continuity errors : sum local = 2.11471e-08, global = 1.22215e-09, cumulative = 6.35487e-06
GAMG: Solving for p, Initial residual = 0.000789146, Final residual = 5.96909e-07, No Iterations 23
time step continuity errors : sum local = 1.15895e-10, global = -6.90183e-12, cumulative = 6.35486e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000444403, Final residual = 5.13304e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000535221, Final residual = 8.17494e-06, No Iterations 6
ExecutionTime = 39.19 s ClockTime = 39 s
Time = 3.7325
Courant Number mean: 0.113603 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000154044, Final residual = 9.27422e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000346783, Final residual = 8.4814e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00115944, Final residual = 0.000109476, No Iterations 7
time step continuity errors : sum local = 2.13094e-08, global = 1.23005e-09, cumulative = 6.35609e-06
GAMG: Solving for p, Initial residual = 0.000783896, Final residual = 5.91734e-07, No Iterations 23
time step continuity errors : sum local = 1.14867e-10, global = -6.85134e-12, cumulative = 6.35609e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000442257, Final residual = 5.10372e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000532882, Final residual = 8.12686e-06, No Iterations 6
ExecutionTime = 39.23 s ClockTime = 39 s
Time = 3.735
Courant Number mean: 0.113589 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000152586, Final residual = 9.18222e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000343429, Final residual = 8.44464e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00113782, Final residual = 0.000106555, No Iterations 7
time step continuity errors : sum local = 2.0736e-08, global = 1.20574e-09, cumulative = 6.35729e-06
GAMG: Solving for p, Initial residual = 0.000772298, Final residual = 5.8508e-07, No Iterations 23
time step continuity errors : sum local = 1.13562e-10, global = -6.80013e-12, cumulative = 6.35729e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000440125, Final residual = 5.07241e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000530521, Final residual = 8.07893e-06, No Iterations 6
ExecutionTime = 39.26 s ClockTime = 40 s
Time = 3.7375
Courant Number mean: 0.113576 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000151109, Final residual = 9.08295e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000340259, Final residual = 8.43283e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00111111, Final residual = 0.000105839, No Iterations 7
time step continuity errors : sum local = 2.05935e-08, global = 1.20113e-09, cumulative = 6.35849e-06
GAMG: Solving for p, Initial residual = 0.000764137, Final residual = 9.92925e-07, No Iterations 22
time step continuity errors : sum local = 1.92697e-10, global = 1.58589e-11, cumulative = 6.3585e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000438005, Final residual = 5.04337e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00052819, Final residual = 8.02932e-06, No Iterations 6
ExecutionTime = 39.29 s ClockTime = 40 s
Time = 3.74
Courant Number mean: 0.113562 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000149666, Final residual = 8.98919e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000337023, Final residual = 8.40396e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00109443, Final residual = 0.00010366, No Iterations 7
time step continuity errors : sum local = 2.01666e-08, global = 1.18329e-09, cumulative = 6.35969e-06
GAMG: Solving for p, Initial residual = 0.000753339, Final residual = 9.8213e-07, No Iterations 22
time step continuity errors : sum local = 1.90592e-10, global = 1.56722e-11, cumulative = 6.3597e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000435893, Final residual = 5.01591e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.00052585, Final residual = 7.98095e-06, No Iterations 6
ExecutionTime = 39.32 s ClockTime = 40 s
Time = 3.7425
Courant Number mean: 0.113549 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000148221, Final residual = 8.89261e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000333883, Final residual = 8.38512e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00106069, Final residual = 0.00010249, No Iterations 7
time step continuity errors : sum local = 1.99366e-08, global = 1.17388e-09, cumulative = 6.36088e-06
GAMG: Solving for p, Initial residual = 0.000744333, Final residual = 9.91103e-07, No Iterations 21
time step continuity errors : sum local = 1.92318e-10, global = -1.06356e-11, cumulative = 6.36087e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000433761, Final residual = 4.98604e-06, No Iterations 5
smoothSolver: Solving for k, Initial residual = 0.000523508, Final residual = 7.93667e-06, No Iterations 6
ExecutionTime = 39.35 s ClockTime = 40 s
Time = 3.745
Courant Number mean: 0.113536 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000146807, Final residual = 8.79948e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000330762, Final residual = 8.35904e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00105556, Final residual = 0.000100578, No Iterations 7
time step continuity errors : sum local = 1.9562e-08, global = 1.16029e-09, cumulative = 6.36203e-06
GAMG: Solving for p, Initial residual = 0.000734169, Final residual = 9.77936e-07, No Iterations 21
time step continuity errors : sum local = 1.89746e-10, global = -1.05182e-11, cumulative = 6.36202e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00043172, Final residual = 9.98976e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000521215, Final residual = 7.88495e-06, No Iterations 6
ExecutionTime = 39.37 s ClockTime = 40 s
Time = 3.7475
Courant Number mean: 0.113523 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000145398, Final residual = 8.70549e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00032772, Final residual = 8.3354e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00102726, Final residual = 9.91965e-05, No Iterations 7
time step continuity errors : sum local = 1.92908e-08, global = 1.15366e-09, cumulative = 6.36317e-06
GAMG: Solving for p, Initial residual = 0.000724816, Final residual = 9.68141e-07, No Iterations 21
time step continuity errors : sum local = 1.87833e-10, global = -1.04523e-11, cumulative = 6.36316e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000429953, Final residual = 9.95545e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000518994, Final residual = 7.83904e-06, No Iterations 6
ExecutionTime = 39.4 s ClockTime = 40 s
Time = 3.75
Courant Number mean: 0.11351 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000144005, Final residual = 8.61263e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000324672, Final residual = 8.30882e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00100732, Final residual = 9.75889e-05, No Iterations 7
time step continuity errors : sum local = 1.89759e-08, global = 1.14112e-09, cumulative = 6.3643e-06
GAMG: Solving for p, Initial residual = 0.000715136, Final residual = 9.56641e-07, No Iterations 21
time step continuity errors : sum local = 1.85588e-10, global = -1.03683e-11, cumulative = 6.36429e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000428193, Final residual = 9.92163e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0005168, Final residual = 7.78998e-06, No Iterations 6
ExecutionTime = 39.43 s ClockTime = 40 s
Time = 3.7525
Courant Number mean: 0.113498 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000142629, Final residual = 8.52001e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000321661, Final residual = 8.28352e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000989005, Final residual = 9.60937e-05, No Iterations 7
time step continuity errors : sum local = 1.8683e-08, global = 1.12647e-09, cumulative = 6.36542e-06
GAMG: Solving for p, Initial residual = 0.000705345, Final residual = 9.44873e-07, No Iterations 21
time step continuity errors : sum local = 1.83293e-10, global = -1.02746e-11, cumulative = 6.36541e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000426428, Final residual = 9.88435e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000514661, Final residual = 7.74383e-06, No Iterations 6
ExecutionTime = 39.46 s ClockTime = 40 s
Time = 3.755
Courant Number mean: 0.113486 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000141275, Final residual = 8.42857e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000318671, Final residual = 8.25677e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000989638, Final residual = 9.45229e-05, No Iterations 7
time step continuity errors : sum local = 1.83757e-08, global = 1.1142e-09, cumulative = 6.36652e-06
GAMG: Solving for p, Initial residual = 0.000695207, Final residual = 9.33176e-07, No Iterations 21
time step continuity errors : sum local = 1.81015e-10, global = -1.01822e-11, cumulative = 6.36651e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000424693, Final residual = 9.84521e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000512592, Final residual = 7.69697e-06, No Iterations 6
ExecutionTime = 39.49 s ClockTime = 40 s
Time = 3.7575
Courant Number mean: 0.113474 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000139927, Final residual = 8.33762e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000315733, Final residual = 8.23006e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0009962, Final residual = 9.27337e-05, No Iterations 7
time step continuity errors : sum local = 1.80263e-08, global = 1.10067e-09, cumulative = 6.36761e-06
GAMG: Solving for p, Initial residual = 0.000685366, Final residual = 9.21289e-07, No Iterations 21
time step continuity errors : sum local = 1.78703e-10, global = -1.00856e-11, cumulative = 6.3676e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000422941, Final residual = 9.80321e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000510511, Final residual = 7.64833e-06, No Iterations 6
ExecutionTime = 39.52 s ClockTime = 40 s
Time = 3.76
Courant Number mean: 0.113462 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000138588, Final residual = 8.24718e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000312826, Final residual = 8.20222e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000950875, Final residual = 9.11066e-05, No Iterations 7
time step continuity errors : sum local = 1.77085e-08, global = 1.08671e-09, cumulative = 6.36869e-06
GAMG: Solving for p, Initial residual = 0.000675626, Final residual = 9.09571e-07, No Iterations 21
time step continuity errors : sum local = 1.76423e-10, global = -9.99245e-12, cumulative = 6.36868e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000421188, Final residual = 9.76113e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00050844, Final residual = 7.59745e-06, No Iterations 6
ExecutionTime = 39.55 s ClockTime = 40 s
Time = 3.7625
Courant Number mean: 0.11345 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000137265, Final residual = 8.15717e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000309982, Final residual = 8.17394e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000930531, Final residual = 8.95867e-05, No Iterations 7
time step continuity errors : sum local = 1.74115e-08, global = 1.07338e-09, cumulative = 6.36975e-06
GAMG: Solving for p, Initial residual = 0.000665766, Final residual = 8.97824e-07, No Iterations 21
time step continuity errors : sum local = 1.74137e-10, global = -9.89836e-12, cumulative = 6.36974e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000419434, Final residual = 9.72262e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000506382, Final residual = 7.54805e-06, No Iterations 6
ExecutionTime = 39.58 s ClockTime = 40 s
Time = 3.765
Courant Number mean: 0.113438 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000135956, Final residual = 8.06815e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000307183, Final residual = 8.14471e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000913809, Final residual = 8.8033e-05, No Iterations 7
time step continuity errors : sum local = 1.71079e-08, global = 1.05996e-09, cumulative = 6.3708e-06
GAMG: Solving for p, Initial residual = 0.000655891, Final residual = 8.85939e-07, No Iterations 21
time step continuity errors : sum local = 1.71822e-10, global = -9.80086e-12, cumulative = 6.37079e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000417683, Final residual = 9.67841e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000504325, Final residual = 7.49692e-06, No Iterations 6
ExecutionTime = 39.6 s ClockTime = 40 s
Time = 3.7675
Courant Number mean: 0.113427 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.00013466, Final residual = 7.97942e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000304403, Final residual = 8.11505e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000897703, Final residual = 8.64433e-05, No Iterations 7
time step continuity errors : sum local = 1.67974e-08, global = 1.04649e-09, cumulative = 6.37184e-06
GAMG: Solving for p, Initial residual = 0.000645965, Final residual = 8.73882e-07, No Iterations 21
time step continuity errors : sum local = 1.69478e-10, global = -9.69984e-12, cumulative = 6.37183e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00041593, Final residual = 9.63386e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000502287, Final residual = 7.44424e-06, No Iterations 6
ExecutionTime = 39.63 s ClockTime = 40 s
Time = 3.77
Courant Number mean: 0.113416 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000133386, Final residual = 7.89198e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000301648, Final residual = 8.08439e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000896883, Final residual = 8.48343e-05, No Iterations 7
time step continuity errors : sum local = 1.64835e-08, global = 1.0328e-09, cumulative = 6.37286e-06
GAMG: Solving for p, Initial residual = 0.000636282, Final residual = 8.61727e-07, No Iterations 21
time step continuity errors : sum local = 1.67117e-10, global = -9.59653e-12, cumulative = 6.37285e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000414181, Final residual = 9.58827e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000500252, Final residual = 7.39587e-06, No Iterations 6
ExecutionTime = 39.65 s ClockTime = 40 s
Time = 3.7725
Courant Number mean: 0.113405 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000132125, Final residual = 7.80504e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000298914, Final residual = 8.05287e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000870228, Final residual = 8.32396e-05, No Iterations 7
time step continuity errors : sum local = 1.61726e-08, global = 1.01972e-09, cumulative = 6.37387e-06
GAMG: Solving for p, Initial residual = 0.000626604, Final residual = 8.49535e-07, No Iterations 21
time step continuity errors : sum local = 1.64749e-10, global = -9.49256e-12, cumulative = 6.37386e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000412442, Final residual = 9.54649e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000498224, Final residual = 7.34579e-06, No Iterations 6
ExecutionTime = 39.68 s ClockTime = 40 s
Time = 3.775
Courant Number mean: 0.113394 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000130877, Final residual = 7.71949e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000296222, Final residual = 8.02058e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000855213, Final residual = 8.16513e-05, No Iterations 7
time step continuity errors : sum local = 1.5863e-08, global = 1.0064e-09, cumulative = 6.37487e-06
GAMG: Solving for p, Initial residual = 0.000617301, Final residual = 8.37262e-07, No Iterations 21
time step continuity errors : sum local = 1.62366e-10, global = -9.38676e-12, cumulative = 6.37486e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000410732, Final residual = 9.50014e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000496213, Final residual = 7.29101e-06, No Iterations 6
ExecutionTime = 39.71 s ClockTime = 40 s
Time = 3.7775
Courant Number mean: 0.113383 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000129639, Final residual = 7.63459e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000293554, Final residual = 7.98734e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000841502, Final residual = 8.00639e-05, No Iterations 7
time step continuity errors : sum local = 1.55536e-08, global = 9.93099e-10, cumulative = 6.37585e-06
GAMG: Solving for p, Initial residual = 0.000607764, Final residual = 8.24963e-07, No Iterations 21
time step continuity errors : sum local = 1.59978e-10, global = -9.2798e-12, cumulative = 6.37584e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000409056, Final residual = 9.45487e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00049425, Final residual = 7.23681e-06, No Iterations 6
ExecutionTime = 39.74 s ClockTime = 40 s
Time = 3.78
Courant Number mean: 0.113373 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000128412, Final residual = 7.55035e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000290901, Final residual = 7.95347e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000831419, Final residual = 7.8485e-05, No Iterations 7
time step continuity errors : sum local = 1.52459e-08, global = 9.79707e-10, cumulative = 6.37682e-06
GAMG: Solving for p, Initial residual = 0.000598326, Final residual = 8.12659e-07, No Iterations 21
time step continuity errors : sum local = 1.57588e-10, global = -9.17184e-12, cumulative = 6.37681e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000407429, Final residual = 9.41377e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000492359, Final residual = 7.18485e-06, No Iterations 6
ExecutionTime = 39.77 s ClockTime = 40 s
Time = 3.7825
Courant Number mean: 0.113363 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000127206, Final residual = 7.46695e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000288283, Final residual = 7.91858e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000840621, Final residual = 7.68856e-05, No Iterations 7
time step continuity errors : sum local = 1.49342e-08, global = 9.66184e-10, cumulative = 6.37778e-06
GAMG: Solving for p, Initial residual = 0.000588899, Final residual = 8.00361e-07, No Iterations 21
time step continuity errors : sum local = 1.55201e-10, global = -9.06293e-12, cumulative = 6.37777e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000405826, Final residual = 9.36747e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000490539, Final residual = 7.13034e-06, No Iterations 6
ExecutionTime = 39.8 s ClockTime = 40 s
Time = 3.785
Courant Number mean: 0.113353 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000126011, Final residual = 7.3842e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00028568, Final residual = 7.88284e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000814188, Final residual = 7.5685e-05, No Iterations 7
time step continuity errors : sum local = 1.47001e-08, global = 9.38846e-10, cumulative = 6.37871e-06
GAMG: Solving for p, Initial residual = 0.000580026, Final residual = 7.87045e-07, No Iterations 21
time step continuity errors : sum local = 1.52616e-10, global = -8.94084e-12, cumulative = 6.3787e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000404242, Final residual = 9.32132e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000488722, Final residual = 7.07339e-06, No Iterations 6
ExecutionTime = 39.83 s ClockTime = 40 s
Time = 3.7875
Courant Number mean: 0.113343 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000124832, Final residual = 7.30252e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000283109, Final residual = 7.84655e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000799205, Final residual = 7.41767e-05, No Iterations 7
time step continuity errors : sum local = 1.44062e-08, global = 9.26638e-10, cumulative = 6.37963e-06
GAMG: Solving for p, Initial residual = 0.000570681, Final residual = 7.74838e-07, No Iterations 21
time step continuity errors : sum local = 1.50246e-10, global = -8.82929e-12, cumulative = 6.37962e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000402654, Final residual = 9.27781e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000486902, Final residual = 7.0206e-06, No Iterations 6
ExecutionTime = 39.86 s ClockTime = 40 s
Time = 3.79
Courant Number mean: 0.113333 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000123669, Final residual = 7.22229e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00028055, Final residual = 7.80881e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000786978, Final residual = 7.26417e-05, No Iterations 7
time step continuity errors : sum local = 1.41072e-08, global = 9.13353e-10, cumulative = 6.38053e-06
GAMG: Solving for p, Initial residual = 0.000561263, Final residual = 7.62682e-07, No Iterations 21
time step continuity errors : sum local = 1.47886e-10, global = -8.7184e-12, cumulative = 6.38052e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000401058, Final residual = 9.23404e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000485095, Final residual = 6.96208e-06, No Iterations 6
ExecutionTime = 39.89 s ClockTime = 40 s
Time = 3.7925
Courant Number mean: 0.113323 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000122517, Final residual = 7.143e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000278026, Final residual = 7.77054e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000781098, Final residual = 7.11249e-05, No Iterations 7
time step continuity errors : sum local = 1.38117e-08, global = 9.00279e-10, cumulative = 6.38142e-06
GAMG: Solving for p, Initial residual = 0.000551757, Final residual = 7.5056e-07, No Iterations 21
time step continuity errors : sum local = 1.45533e-10, global = -8.60674e-12, cumulative = 6.38141e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000399491, Final residual = 9.18915e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000483288, Final residual = 6.90712e-06, No Iterations 6
ExecutionTime = 39.93 s ClockTime = 40 s
Time = 3.795
Courant Number mean: 0.113314 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000121382, Final residual = 7.06423e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000275524, Final residual = 7.7313e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000777703, Final residual = 6.96121e-05, No Iterations 7
time step continuity errors : sum local = 1.35173e-08, global = 8.87039e-10, cumulative = 6.3823e-06
GAMG: Solving for p, Initial residual = 0.000542564, Final residual = 7.3845e-07, No Iterations 21
time step continuity errors : sum local = 1.43184e-10, global = -8.49432e-12, cumulative = 6.38229e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000397926, Final residual = 9.14547e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000481482, Final residual = 6.85016e-06, No Iterations 6
ExecutionTime = 39.96 s ClockTime = 40 s
Time = 3.7975
Courant Number mean: 0.113305 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000120263, Final residual = 6.98707e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000273044, Final residual = 7.69155e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000768299, Final residual = 6.81075e-05, No Iterations 7
time step continuity errors : sum local = 1.32244e-08, global = 8.73661e-10, cumulative = 6.38317e-06
GAMG: Solving for p, Initial residual = 0.000533045, Final residual = 7.2639e-07, No Iterations 21
time step continuity errors : sum local = 1.40845e-10, global = -8.38138e-12, cumulative = 6.38316e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000396387, Final residual = 9.09865e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000479682, Final residual = 6.79292e-06, No Iterations 6
ExecutionTime = 40 s ClockTime = 40 s
Time = 3.8
Courant Number mean: 0.113296 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000119158, Final residual = 6.91073e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000270593, Final residual = 7.65102e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000758578, Final residual = 6.66212e-05, No Iterations 7
time step continuity errors : sum local = 1.29353e-08, global = 8.60245e-10, cumulative = 6.38402e-06
GAMG: Solving for p, Initial residual = 0.000523814, Final residual = 7.14384e-07, No Iterations 21
time step continuity errors : sum local = 1.38517e-10, global = -8.26881e-12, cumulative = 6.38401e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000394875, Final residual = 9.05284e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000477904, Final residual = 6.73665e-06, No Iterations 6
ExecutionTime = 40.06 s ClockTime = 40 s
Time = 3.8025
Courant Number mean: 0.113287 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000118064, Final residual = 6.83538e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000268168, Final residual = 7.60971e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000748026, Final residual = 6.5123e-05, No Iterations 7
time step continuity errors : sum local = 1.26439e-08, global = 8.47124e-10, cumulative = 6.38486e-06
GAMG: Solving for p, Initial residual = 0.000514556, Final residual = 7.02306e-07, No Iterations 21
time step continuity errors : sum local = 1.36176e-10, global = -8.15389e-12, cumulative = 6.38485e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000393346, Final residual = 9.01372e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000476166, Final residual = 6.67937e-06, No Iterations 6
ExecutionTime = 40.09 s ClockTime = 40 s
Time = 3.805
Courant Number mean: 0.113279 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000116983, Final residual = 6.76116e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000265773, Final residual = 7.56755e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000733048, Final residual = 6.36824e-05, No Iterations 7
time step continuity errors : sum local = 1.23637e-08, global = 8.34143e-10, cumulative = 6.38568e-06
GAMG: Solving for p, Initial residual = 0.000505412, Final residual = 6.90321e-07, No Iterations 21
time step continuity errors : sum local = 1.33851e-10, global = -8.04017e-12, cumulative = 6.38567e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00039184, Final residual = 8.97007e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000474475, Final residual = 6.61796e-06, No Iterations 6
ExecutionTime = 40.13 s ClockTime = 40 s
Time = 3.8075
Courant Number mean: 0.11327 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000115914, Final residual = 6.68786e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000263398, Final residual = 7.52461e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000755291, Final residual = 6.22495e-05, No Iterations 7
time step continuity errors : sum local = 1.20847e-08, global = 8.21065e-10, cumulative = 6.3865e-06
GAMG: Solving for p, Initial residual = 0.000496902, Final residual = 6.78447e-07, No Iterations 21
time step continuity errors : sum local = 1.31545e-10, global = -7.92891e-12, cumulative = 6.38649e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000390372, Final residual = 8.92196e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000472854, Final residual = 6.5568e-06, No Iterations 6
ExecutionTime = 40.16 s ClockTime = 40 s
Time = 3.81
Courant Number mean: 0.113262 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000114856, Final residual = 6.6155e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000261047, Final residual = 7.48073e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000759774, Final residual = 6.08074e-05, No Iterations 7
time step continuity errors : sum local = 1.18039e-08, global = 8.07276e-10, cumulative = 6.3873e-06
GAMG: Solving for p, Initial residual = 0.000488863, Final residual = 6.6674e-07, No Iterations 21
time step continuity errors : sum local = 1.29272e-10, global = -7.81629e-12, cumulative = 6.38729e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000388878, Final residual = 8.87403e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000471257, Final residual = 6.49803e-06, No Iterations 6
ExecutionTime = 40.19 s ClockTime = 40 s
Time = 3.8125
Courant Number mean: 0.113254 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000113813, Final residual = 6.54444e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000258737, Final residual = 7.43619e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00074613, Final residual = 5.94249e-05, No Iterations 7
time step continuity errors : sum local = 1.15348e-08, global = 7.96223e-10, cumulative = 6.38808e-06
GAMG: Solving for p, Initial residual = 0.000480647, Final residual = 6.55048e-07, No Iterations 21
time step continuity errors : sum local = 1.27002e-10, global = -7.70143e-12, cumulative = 6.38808e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000387454, Final residual = 8.8289e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000469689, Final residual = 6.442e-06, No Iterations 6
ExecutionTime = 40.22 s ClockTime = 40 s
Time = 3.815
Courant Number mean: 0.113246 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000112787, Final residual = 6.47421e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000256419, Final residual = 7.39046e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000727904, Final residual = 5.80619e-05, No Iterations 7
time step continuity errors : sum local = 1.12696e-08, global = 7.82802e-10, cumulative = 6.38886e-06
GAMG: Solving for p, Initial residual = 0.000471149, Final residual = 6.43556e-07, No Iterations 21
time step continuity errors : sum local = 1.24771e-10, global = -7.59271e-12, cumulative = 6.38885e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000386047, Final residual = 8.7844e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000468124, Final residual = 6.38031e-06, No Iterations 6
ExecutionTime = 40.25 s ClockTime = 41 s
Time = 3.8175
Courant Number mean: 0.113238 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000111769, Final residual = 6.40525e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000254172, Final residual = 7.34416e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000713876, Final residual = 5.67308e-05, No Iterations 7
time step continuity errors : sum local = 1.10106e-08, global = 7.70348e-10, cumulative = 6.38962e-06
GAMG: Solving for p, Initial residual = 0.000462222, Final residual = 6.31555e-07, No Iterations 21
time step continuity errors : sum local = 1.22442e-10, global = -7.47135e-12, cumulative = 6.38961e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000384648, Final residual = 8.74294e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000466551, Final residual = 6.31779e-06, No Iterations 6
ExecutionTime = 40.28 s ClockTime = 41 s
Time = 3.82
Courant Number mean: 0.113231 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000110764, Final residual = 6.33727e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00025195, Final residual = 7.2972e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00069923, Final residual = 5.53882e-05, No Iterations 7
time step continuity errors : sum local = 1.07494e-08, global = 7.58419e-10, cumulative = 6.39037e-06
GAMG: Solving for p, Initial residual = 0.000453383, Final residual = 6.19765e-07, No Iterations 21
time step continuity errors : sum local = 1.20154e-10, global = -7.35267e-12, cumulative = 6.39036e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000383263, Final residual = 8.69989e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000464985, Final residual = 6.2577e-06, No Iterations 6
ExecutionTime = 40.31 s ClockTime = 41 s
Time = 3.8225
Courant Number mean: 0.113223 max: 0.616698
smoothSolver: Solving for Ux, Initial residual = 0.000109773, Final residual = 6.27059e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000249733, Final residual = 7.24946e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000683252, Final residual = 5.40618e-05, No Iterations 7
time step continuity errors : sum local = 1.04914e-08, global = 7.45994e-10, cumulative = 6.39111e-06
GAMG: Solving for p, Initial residual = 0.000444965, Final residual = 6.08701e-07, No Iterations 21
time step continuity errors : sum local = 1.18006e-10, global = -7.24602e-12, cumulative = 6.3911e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000381895, Final residual = 8.65735e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000463425, Final residual = 6.19468e-06, No Iterations 6
ExecutionTime = 40.34 s ClockTime = 41 s
Time = 3.825
Courant Number mean: 0.113216 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000108798, Final residual = 6.20498e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000247533, Final residual = 7.201e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000671364, Final residual = 5.2783e-05, No Iterations 7
time step continuity errors : sum local = 1.02427e-08, global = 7.33966e-10, cumulative = 6.39184e-06
GAMG: Solving for p, Initial residual = 0.000436678, Final residual = 5.97417e-07, No Iterations 21
time step continuity errors : sum local = 1.15817e-10, global = -7.13283e-12, cumulative = 6.39183e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000380546, Final residual = 8.61375e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00046187, Final residual = 6.13421e-06, No Iterations 6
ExecutionTime = 40.37 s ClockTime = 41 s
Time = 3.8275
Courant Number mean: 0.113209 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000107838, Final residual = 6.14058e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000245347, Final residual = 7.15182e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.0006484, Final residual = 5.14854e-05, No Iterations 7
time step continuity errors : sum local = 9.99026e-09, global = 7.22201e-10, cumulative = 6.39255e-06
GAMG: Solving for p, Initial residual = 0.000428384, Final residual = 5.8641e-07, No Iterations 21
time step continuity errors : sum local = 1.13679e-10, global = -7.01894e-12, cumulative = 6.39255e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000379236, Final residual = 8.57114e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000460327, Final residual = 6.07283e-06, No Iterations 6
ExecutionTime = 40.41 s ClockTime = 41 s
Time = 3.83
Courant Number mean: 0.113203 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000106892, Final residual = 6.07718e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000243186, Final residual = 7.10188e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000637821, Final residual = 5.02889e-05, No Iterations 7
time step continuity errors : sum local = 9.75734e-09, global = 7.10546e-10, cumulative = 6.39326e-06
GAMG: Solving for p, Initial residual = 0.000420443, Final residual = 5.75414e-07, No Iterations 21
time step continuity errors : sum local = 1.11542e-10, global = -6.90727e-12, cumulative = 6.39325e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000377971, Final residual = 8.52967e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000458834, Final residual = 6.01117e-06, No Iterations 6
ExecutionTime = 40.43 s ClockTime = 41 s
Time = 3.8325
Courant Number mean: 0.113196 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000105958, Final residual = 6.0146e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000241043, Final residual = 7.05132e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000623053, Final residual = 4.91266e-05, No Iterations 7
time step continuity errors : sum local = 9.53107e-09, global = 6.99166e-10, cumulative = 6.39395e-06
GAMG: Solving for p, Initial residual = 0.000412767, Final residual = 9.87456e-07, No Iterations 19
time step continuity errors : sum local = 1.91407e-10, global = -1.0868e-11, cumulative = 6.39394e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000376726, Final residual = 8.48919e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000457396, Final residual = 5.95176e-06, No Iterations 6
ExecutionTime = 40.46 s ClockTime = 41 s
Time = 3.835
Courant Number mean: 0.113189 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000105036, Final residual = 5.95349e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000238921, Final residual = 7.00026e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000611396, Final residual = 4.77703e-05, No Iterations 7
time step continuity errors : sum local = 9.26724e-09, global = 6.88189e-10, cumulative = 6.39463e-06
GAMG: Solving for p, Initial residual = 0.000404743, Final residual = 9.67909e-07, No Iterations 19
time step continuity errors : sum local = 1.87612e-10, global = -1.06926e-11, cumulative = 6.39462e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000375483, Final residual = 8.44835e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000455994, Final residual = 5.8878e-06, No Iterations 6
ExecutionTime = 40.5 s ClockTime = 41 s
Time = 3.8375
Courant Number mean: 0.113183 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000104127, Final residual = 5.89363e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000236822, Final residual = 6.94812e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000605259, Final residual = 4.66985e-05, No Iterations 7
time step continuity errors : sum local = 9.05866e-09, global = 6.76452e-10, cumulative = 6.39529e-06
GAMG: Solving for p, Initial residual = 0.00039758, Final residual = 9.48788e-07, No Iterations 19
time step continuity errors : sum local = 1.83898e-10, global = -1.05127e-11, cumulative = 6.39528e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000374257, Final residual = 8.41018e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000454599, Final residual = 5.82619e-06, No Iterations 6
ExecutionTime = 40.53 s ClockTime = 41 s
Time = 3.84
Courant Number mean: 0.113177 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000103234, Final residual = 5.83462e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000234746, Final residual = 6.89586e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00059765, Final residual = 4.55264e-05, No Iterations 7
time step continuity errors : sum local = 8.83082e-09, global = 6.66115e-10, cumulative = 6.39595e-06
GAMG: Solving for p, Initial residual = 0.000390075, Final residual = 9.30096e-07, No Iterations 19
time step continuity errors : sum local = 1.80272e-10, global = -1.03374e-11, cumulative = 6.39594e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000373042, Final residual = 8.37007e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000453212, Final residual = 9.97107e-06, No Iterations 5
ExecutionTime = 40.56 s ClockTime = 41 s
Time = 3.8425
Courant Number mean: 0.113171 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000102355, Final residual = 5.77713e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000232674, Final residual = 6.84354e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000584688, Final residual = 4.4294e-05, No Iterations 7
time step continuity errors : sum local = 8.59137e-09, global = 6.49498e-10, cumulative = 6.39659e-06
GAMG: Solving for p, Initial residual = 0.000382454, Final residual = 9.09805e-07, No Iterations 19
time step continuity errors : sum local = 1.76337e-10, global = -1.01526e-11, cumulative = 6.39658e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000371777, Final residual = 8.32401e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000451801, Final residual = 9.8817e-06, No Iterations 5
ExecutionTime = 40.59 s ClockTime = 41 s
Time = 3.845
Courant Number mean: 0.113165 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000101489, Final residual = 5.72063e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000230648, Final residual = 6.79031e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000568059, Final residual = 4.32736e-05, No Iterations 7
time step continuity errors : sum local = 8.39308e-09, global = 6.41096e-10, cumulative = 6.39722e-06
GAMG: Solving for p, Initial residual = 0.000374736, Final residual = 8.91802e-07, No Iterations 19
time step continuity errors : sum local = 1.72845e-10, global = -9.97863e-12, cumulative = 6.39721e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000370483, Final residual = 8.28114e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000450402, Final residual = 9.79155e-06, No Iterations 5
ExecutionTime = 40.61 s ClockTime = 41 s
Time = 3.8475
Courant Number mean: 0.113159 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 0.000100637, Final residual = 5.66523e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000228636, Final residual = 6.73621e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000555103, Final residual = 4.22778e-05, No Iterations 7
time step continuity errors : sum local = 8.1996e-09, global = 6.31708e-10, cumulative = 6.39784e-06
GAMG: Solving for p, Initial residual = 0.000367656, Final residual = 8.74518e-07, No Iterations 19
time step continuity errors : sum local = 1.69493e-10, global = -9.8122e-12, cumulative = 6.39783e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000369241, Final residual = 8.23685e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000449027, Final residual = 9.70789e-06, No Iterations 5
ExecutionTime = 40.64 s ClockTime = 41 s
Time = 3.85
Courant Number mean: 0.113154 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.9796e-05, Final residual = 5.61124e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000226651, Final residual = 6.68169e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000549197, Final residual = 4.12808e-05, No Iterations 7
time step continuity errors : sum local = 8.00594e-09, global = 6.22742e-10, cumulative = 6.39845e-06
GAMG: Solving for p, Initial residual = 0.00036079, Final residual = 8.57714e-07, No Iterations 19
time step continuity errors : sum local = 1.66235e-10, global = -9.64969e-12, cumulative = 6.39844e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000368045, Final residual = 8.19582e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000447676, Final residual = 9.61916e-06, No Iterations 5
ExecutionTime = 40.67 s ClockTime = 41 s
Time = 3.8525
Courant Number mean: 0.113149 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.89664e-05, Final residual = 5.55814e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000224682, Final residual = 6.62653e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000538992, Final residual = 4.03558e-05, No Iterations 7
time step continuity errors : sum local = 7.8263e-09, global = 6.13925e-10, cumulative = 6.39906e-06
GAMG: Solving for p, Initial residual = 0.000353811, Final residual = 8.41402e-07, No Iterations 19
time step continuity errors : sum local = 1.63074e-10, global = -9.4915e-12, cumulative = 6.39905e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000366872, Final residual = 8.15319e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000446334, Final residual = 9.53788e-06, No Iterations 5
ExecutionTime = 40.7 s ClockTime = 41 s
Time = 3.855
Courant Number mean: 0.113143 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.81481e-05, Final residual = 5.50625e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000222741, Final residual = 6.57082e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000528187, Final residual = 3.94675e-05, No Iterations 7
time step continuity errors : sum local = 7.65374e-09, global = 6.05345e-10, cumulative = 6.39965e-06
GAMG: Solving for p, Initial residual = 0.000347048, Final residual = 8.25615e-07, No Iterations 19
time step continuity errors : sum local = 1.60013e-10, global = -9.33883e-12, cumulative = 6.39964e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000365723, Final residual = 8.11295e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000445024, Final residual = 9.45232e-06, No Iterations 5
ExecutionTime = 40.72 s ClockTime = 41 s
Time = 3.8575
Courant Number mean: 0.113138 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.73422e-05, Final residual = 5.45593e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000220842, Final residual = 6.51463e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000528598, Final residual = 3.86042e-05, No Iterations 7
time step continuity errors : sum local = 7.48605e-09, global = 5.97e-10, cumulative = 6.40024e-06
GAMG: Solving for p, Initial residual = 0.000340709, Final residual = 8.10287e-07, No Iterations 19
time step continuity errors : sum local = 1.57041e-10, global = -9.19176e-12, cumulative = 6.40023e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000364597, Final residual = 8.07692e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000443783, Final residual = 9.36799e-06, No Iterations 5
ExecutionTime = 40.75 s ClockTime = 41 s
Time = 3.86
Courant Number mean: 0.113134 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.65486e-05, Final residual = 5.40677e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000218976, Final residual = 6.45795e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000536208, Final residual = 3.77801e-05, No Iterations 7
time step continuity errors : sum local = 7.32597e-09, global = 5.89137e-10, cumulative = 6.40082e-06
GAMG: Solving for p, Initial residual = 0.000334728, Final residual = 7.95395e-07, No Iterations 19
time step continuity errors : sum local = 1.54153e-10, global = -9.04946e-12, cumulative = 6.40081e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000363497, Final residual = 8.03691e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000442586, Final residual = 9.2874e-06, No Iterations 5
ExecutionTime = 40.78 s ClockTime = 41 s
Time = 3.8625
Courant Number mean: 0.113129 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.57639e-05, Final residual = 5.35874e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00021711, Final residual = 6.40079e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000536729, Final residual = 3.69949e-05, No Iterations 7
time step continuity errors : sum local = 7.1735e-09, global = 5.81848e-10, cumulative = 6.40139e-06
GAMG: Solving for p, Initial residual = 0.000329133, Final residual = 7.80901e-07, No Iterations 19
time step continuity errors : sum local = 1.51343e-10, global = -8.91194e-12, cumulative = 6.40138e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000362412, Final residual = 7.9982e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000441434, Final residual = 9.20311e-06, No Iterations 5
ExecutionTime = 40.81 s ClockTime = 41 s
Time = 3.865
Courant Number mean: 0.113124 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.49886e-05, Final residual = 5.31187e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000215251, Final residual = 6.3433e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.00051866, Final residual = 3.62097e-05, No Iterations 7
time step continuity errors : sum local = 7.02096e-09, global = 5.74695e-10, cumulative = 6.40196e-06
GAMG: Solving for p, Initial residual = 0.000322735, Final residual = 7.66831e-07, No Iterations 19
time step continuity errors : sum local = 1.48614e-10, global = -8.77988e-12, cumulative = 6.40195e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000361339, Final residual = 7.96091e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000440291, Final residual = 9.12895e-06, No Iterations 5
ExecutionTime = 40.83 s ClockTime = 41 s
Time = 3.8675
Courant Number mean: 0.11312 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.42272e-05, Final residual = 5.26602e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000213396, Final residual = 6.28539e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000507172, Final residual = 3.54362e-05, No Iterations 7
time step continuity errors : sum local = 6.87074e-09, global = 5.67487e-10, cumulative = 6.40252e-06
GAMG: Solving for p, Initial residual = 0.000317098, Final residual = 7.53261e-07, No Iterations 19
time step continuity errors : sum local = 1.45982e-10, global = -8.65511e-12, cumulative = 6.40251e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000360268, Final residual = 7.92374e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000439168, Final residual = 9.04674e-06, No Iterations 5
ExecutionTime = 40.86 s ClockTime = 41 s
Time = 3.87
Courant Number mean: 0.113116 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.34742e-05, Final residual = 5.22153e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000211548, Final residual = 6.2272e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000496242, Final residual = 3.46866e-05, No Iterations 7
time step continuity errors : sum local = 6.72516e-09, global = 5.60742e-10, cumulative = 6.40307e-06
GAMG: Solving for p, Initial residual = 0.000311592, Final residual = 7.40092e-07, No Iterations 19
time step continuity errors : sum local = 1.43429e-10, global = -8.53428e-12, cumulative = 6.40306e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000359206, Final residual = 7.88436e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000438055, Final residual = 8.96449e-06, No Iterations 5
ExecutionTime = 40.89 s ClockTime = 41 s
Time = 3.8725
Courant Number mean: 0.113111 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.27322e-05, Final residual = 5.17754e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000209714, Final residual = 6.16878e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000490795, Final residual = 3.39814e-05, No Iterations 7
time step continuity errors : sum local = 6.58822e-09, global = 5.54296e-10, cumulative = 6.40361e-06
GAMG: Solving for p, Initial residual = 0.000306198, Final residual = 7.27389e-07, No Iterations 19
time step continuity errors : sum local = 1.40966e-10, global = -8.419e-12, cumulative = 6.40361e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000358178, Final residual = 7.85043e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000436948, Final residual = 8.88533e-06, No Iterations 5
ExecutionTime = 40.91 s ClockTime = 41 s
Time = 3.875
Courant Number mean: 0.113107 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.19977e-05, Final residual = 5.13468e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.00020789, Final residual = 6.11018e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000485547, Final residual = 3.32988e-05, No Iterations 7
time step continuity errors : sum local = 6.4557e-09, global = 5.48174e-10, cumulative = 6.40415e-06
GAMG: Solving for p, Initial residual = 0.000301192, Final residual = 7.15032e-07, No Iterations 19
time step continuity errors : sum local = 1.3857e-10, global = -8.30792e-12, cumulative = 6.40415e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000357166, Final residual = 7.81485e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000435859, Final residual = 8.80934e-06, No Iterations 5
ExecutionTime = 40.94 s ClockTime = 41 s
Time = 3.8775
Courant Number mean: 0.113104 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.12728e-05, Final residual = 5.09278e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000206089, Final residual = 6.05146e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000480102, Final residual = 3.26626e-05, No Iterations 7
time step continuity errors : sum local = 6.33218e-09, global = 5.42516e-10, cumulative = 6.40469e-06
GAMG: Solving for p, Initial residual = 0.000295968, Final residual = 7.02836e-07, No Iterations 19
time step continuity errors : sum local = 1.36206e-10, global = -8.19677e-12, cumulative = 6.40468e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000356194, Final residual = 7.78053e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0004348, Final residual = 8.73137e-06, No Iterations 5
ExecutionTime = 40.96 s ClockTime = 41 s
Time = 3.88
Courant Number mean: 0.1131 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 9.05611e-05, Final residual = 5.05168e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000204304, Final residual = 5.99269e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000487052, Final residual = 3.21346e-05, No Iterations 7
time step continuity errors : sum local = 6.22965e-09, global = 5.37287e-10, cumulative = 6.40522e-06
GAMG: Solving for p, Initial residual = 0.000291539, Final residual = 6.89273e-07, No Iterations 19
time step continuity errors : sum local = 1.33576e-10, global = -8.05792e-12, cumulative = 6.40521e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000355238, Final residual = 7.7449e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000433805, Final residual = 8.65361e-06, No Iterations 5
ExecutionTime = 40.99 s ClockTime = 41 s
Time = 3.8825
Courant Number mean: 0.113096 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.98607e-05, Final residual = 5.01143e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000202533, Final residual = 5.9342e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000464696, Final residual = 3.14483e-05, No Iterations 7
time step continuity errors : sum local = 6.09643e-09, global = 5.3204e-10, cumulative = 6.40574e-06
GAMG: Solving for p, Initial residual = 0.000286737, Final residual = 6.83118e-07, No Iterations 19
time step continuity errors : sum local = 1.32383e-10, global = -8.05472e-12, cumulative = 6.40573e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000354299, Final residual = 7.71222e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000432863, Final residual = 8.57445e-06, No Iterations 5
ExecutionTime = 41.01 s ClockTime = 41 s
Time = 3.885
Courant Number mean: 0.113093 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.91719e-05, Final residual = 4.97206e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000200786, Final residual = 9.95374e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000524214, Final residual = 4.21117e-05, No Iterations 7
time step continuity errors : sum local = 8.16341e-09, global = 8.37979e-10, cumulative = 6.40657e-06
GAMG: Solving for p, Initial residual = 0.000305093, Final residual = 9.49482e-07, No Iterations 19
time step continuity errors : sum local = 1.83995e-10, global = -1.30839e-11, cumulative = 6.40656e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000353373, Final residual = 7.67985e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000431929, Final residual = 8.50121e-06, No Iterations 5
ExecutionTime = 41.04 s ClockTime = 41 s
Time = 3.8875
Courant Number mean: 0.11309 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.83992e-05, Final residual = 4.92671e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000200361, Final residual = 5.95045e-06, No Iterations 5
GAMG: Solving for p, Initial residual = 0.000434511, Final residual = 2.93015e-05, No Iterations 7
time step continuity errors : sum local = 5.68016e-09, global = 5.97028e-10, cumulative = 6.40716e-06
GAMG: Solving for p, Initial residual = 0.000272652, Final residual = 6.1659e-07, No Iterations 19
time step continuity errors : sum local = 1.19487e-10, global = -7.21581e-12, cumulative = 6.40715e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000352467, Final residual = 7.65022e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000431008, Final residual = 8.43035e-06, No Iterations 5
ExecutionTime = 41.06 s ClockTime = 41 s
Time = 3.89
Courant Number mean: 0.113086 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.78708e-05, Final residual = 4.90125e-06, No Iterations 3
smoothSolver: Solving for Uy, Initial residual = 0.000196808, Final residual = 9.65785e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000512598, Final residual = 4.7849e-05, No Iterations 7
time step continuity errors : sum local = 9.27469e-09, global = 1.05896e-09, cumulative = 6.40821e-06
GAMG: Solving for p, Initial residual = 0.000317041, Final residual = 5.97994e-07, No Iterations 21
time step continuity errors : sum local = 1.15879e-10, global = -8.54112e-12, cumulative = 6.4082e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000351566, Final residual = 7.62041e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000430086, Final residual = 8.3608e-06, No Iterations 5
ExecutionTime = 41.09 s ClockTime = 41 s
Time = 3.8925
Courant Number mean: 0.113083 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.70454e-05, Final residual = 9.94904e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000197285, Final residual = 9.91881e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000609316, Final residual = 3.24855e-05, No Iterations 9
time step continuity errors : sum local = 6.29704e-09, global = 4.56268e-10, cumulative = 6.40866e-06
GAMG: Solving for p, Initial residual = 0.000506566, Final residual = 6.27649e-07, No Iterations 21
time step continuity errors : sum local = 1.2155e-10, global = -7.52073e-12, cumulative = 6.40865e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000350614, Final residual = 7.58935e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000429164, Final residual = 8.29181e-06, No Iterations 5
ExecutionTime = 41.12 s ClockTime = 41 s
Time = 3.895
Courant Number mean: 0.113081 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.65428e-05, Final residual = 9.97137e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000194658, Final residual = 9.63586e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000632052, Final residual = 4.74807e-05, No Iterations 7
time step continuity errors : sum local = 9.20052e-09, global = 8.02587e-10, cumulative = 6.40945e-06
GAMG: Solving for p, Initial residual = 0.00045105, Final residual = 9.49343e-07, No Iterations 19
time step continuity errors : sum local = 1.83907e-10, global = -1.10539e-11, cumulative = 6.40944e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000349731, Final residual = 7.56127e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000428247, Final residual = 8.22225e-06, No Iterations 5
ExecutionTime = 41.15 s ClockTime = 41 s
Time = 3.8975
Courant Number mean: 0.113078 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.58524e-05, Final residual = 9.87563e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000193483, Final residual = 9.67081e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000581026, Final residual = 4.73151e-05, No Iterations 7
time step continuity errors : sum local = 9.16971e-09, global = 7.33634e-10, cumulative = 6.41017e-06
GAMG: Solving for p, Initial residual = 0.000445962, Final residual = 9.09866e-07, No Iterations 19
time step continuity errors : sum local = 1.76247e-10, global = -1.07339e-11, cumulative = 6.41016e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000348871, Final residual = 7.53363e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000427345, Final residual = 8.15754e-06, No Iterations 5
ExecutionTime = 41.18 s ClockTime = 41 s
Time = 3.9
Courant Number mean: 0.113075 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.52827e-05, Final residual = 9.83002e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000191483, Final residual = 9.49854e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00057258, Final residual = 4.58748e-05, No Iterations 7
time step continuity errors : sum local = 8.88952e-09, global = 7.38257e-10, cumulative = 6.4109e-06
GAMG: Solving for p, Initial residual = 0.000429945, Final residual = 9.1523e-07, No Iterations 19
time step continuity errors : sum local = 1.77297e-10, global = -1.095e-11, cumulative = 6.41089e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000348027, Final residual = 7.5071e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000426455, Final residual = 8.09356e-06, No Iterations 5
ExecutionTime = 41.23 s ClockTime = 41 s
Time = 3.9025
Courant Number mean: 0.113072 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.46475e-05, Final residual = 9.75688e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00019015, Final residual = 9.45627e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000560882, Final residual = 4.53632e-05, No Iterations 7
time step continuity errors : sum local = 8.79066e-09, global = 7.18578e-10, cumulative = 6.41161e-06
GAMG: Solving for p, Initial residual = 0.000428389, Final residual = 9.03101e-07, No Iterations 19
time step continuity errors : sum local = 1.74945e-10, global = -1.09547e-11, cumulative = 6.4116e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00034718, Final residual = 7.48253e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000425588, Final residual = 8.03083e-06, No Iterations 5
ExecutionTime = 41.26 s ClockTime = 42 s
Time = 3.905
Courant Number mean: 0.11307 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.40662e-05, Final residual = 9.69927e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000188446, Final residual = 9.33642e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000559741, Final residual = 4.46779e-05, No Iterations 7
time step continuity errors : sum local = 8.65743e-09, global = 7.27465e-10, cumulative = 6.41232e-06
GAMG: Solving for p, Initial residual = 0.000420023, Final residual = 9.02617e-07, No Iterations 19
time step continuity errors : sum local = 1.74856e-10, global = -1.10985e-11, cumulative = 6.41231e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000346348, Final residual = 7.45877e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000424749, Final residual = 7.97087e-06, No Iterations 5
ExecutionTime = 41.28 s ClockTime = 42 s
Time = 3.9075
Courant Number mean: 0.113068 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.34661e-05, Final residual = 9.63399e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000186998, Final residual = 9.26529e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00055359, Final residual = 4.40106e-05, No Iterations 7
time step continuity errors : sum local = 8.52826e-09, global = 7.18281e-10, cumulative = 6.41303e-06
GAMG: Solving for p, Initial residual = 0.00041625, Final residual = 8.97757e-07, No Iterations 19
time step continuity errors : sum local = 1.73917e-10, global = -1.12425e-11, cumulative = 6.41302e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000345549, Final residual = 7.43592e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000423944, Final residual = 7.91139e-06, No Iterations 5
ExecutionTime = 41.32 s ClockTime = 42 s
Time = 3.91
Courant Number mean: 0.113066 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.28905e-05, Final residual = 9.57427e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000185429, Final residual = 9.16594e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000546458, Final residual = 4.3443e-05, No Iterations 7
time step continuity errors : sum local = 8.41812e-09, global = 7.25303e-10, cumulative = 6.41375e-06
GAMG: Solving for p, Initial residual = 0.000409999, Final residual = 8.97927e-07, No Iterations 19
time step continuity errors : sum local = 1.73953e-10, global = -1.14563e-11, cumulative = 6.41373e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000344759, Final residual = 7.41452e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000423209, Final residual = 7.85174e-06, No Iterations 5
ExecutionTime = 41.34 s ClockTime = 42 s
Time = 3.9125
Courant Number mean: 0.113063 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.2312e-05, Final residual = 9.51237e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000183961, Final residual = 9.08513e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000547614, Final residual = 4.28258e-05, No Iterations 7
time step continuity errors : sum local = 8.29856e-09, global = 7.23003e-10, cumulative = 6.41446e-06
GAMG: Solving for p, Initial residual = 0.000405597, Final residual = 8.98504e-07, No Iterations 19
time step continuity errors : sum local = 1.74067e-10, global = -1.17201e-11, cumulative = 6.41445e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000343992, Final residual = 7.39455e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000422484, Final residual = 7.79574e-06, No Iterations 5
ExecutionTime = 41.37 s ClockTime = 42 s
Time = 3.915
Courant Number mean: 0.113061 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.17449e-05, Final residual = 9.45277e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00018246, Final residual = 8.99443e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000563992, Final residual = 4.23113e-05, No Iterations 7
time step continuity errors : sum local = 8.19878e-09, global = 7.29335e-10, cumulative = 6.41517e-06
GAMG: Solving for p, Initial residual = 0.000400599, Final residual = 9.02533e-07, No Iterations 19
time step continuity errors : sum local = 1.74852e-10, global = -1.20309e-11, cumulative = 6.41516e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000343238, Final residual = 7.3762e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000421762, Final residual = 7.73948e-06, No Iterations 5
ExecutionTime = 41.4 s ClockTime = 42 s
Time = 3.9175
Courant Number mean: 0.11306 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.11811e-05, Final residual = 9.39318e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000181031, Final residual = 8.91114e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000554408, Final residual = 4.17839e-05, No Iterations 7
time step continuity errors : sum local = 8.09657e-09, global = 7.31868e-10, cumulative = 6.41589e-06
GAMG: Solving for p, Initial residual = 0.000395873, Final residual = 9.09879e-07, No Iterations 19
time step continuity errors : sum local = 1.76277e-10, global = -1.24011e-11, cumulative = 6.41588e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000342501, Final residual = 7.35789e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000421052, Final residual = 7.6888e-06, No Iterations 5
ExecutionTime = 41.43 s ClockTime = 42 s
Time = 3.92
Courant Number mean: 0.113058 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.06282e-05, Final residual = 9.33481e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000179601, Final residual = 8.82469e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000549544, Final residual = 4.14179e-05, No Iterations 7
time step continuity errors : sum local = 8.02555e-09, global = 7.40041e-10, cumulative = 6.41662e-06
GAMG: Solving for p, Initial residual = 0.000391349, Final residual = 9.20935e-07, No Iterations 19
time step continuity errors : sum local = 1.78421e-10, global = -1.27999e-11, cumulative = 6.41661e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000341784, Final residual = 7.34214e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000420356, Final residual = 7.63773e-06, No Iterations 5
ExecutionTime = 41.45 s ClockTime = 42 s
Time = 3.9225
Courant Number mean: 0.113056 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 8.0081e-05, Final residual = 9.27632e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000178184, Final residual = 8.74147e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000541079, Final residual = 4.09394e-05, No Iterations 7
time step continuity errors : sum local = 7.93278e-09, global = 7.46177e-10, cumulative = 6.41736e-06
GAMG: Solving for p, Initial residual = 0.000386992, Final residual = 9.38384e-07, No Iterations 19
time step continuity errors : sum local = 1.81804e-10, global = -1.32794e-11, cumulative = 6.41734e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000341077, Final residual = 7.32605e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000419675, Final residual = 7.58579e-06, No Iterations 5
ExecutionTime = 41.48 s ClockTime = 42 s
Time = 3.925
Courant Number mean: 0.113055 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.95417e-05, Final residual = 9.21857e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000176785, Final residual = 8.65784e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000539158, Final residual = 4.05537e-05, No Iterations 7
time step continuity errors : sum local = 7.85799e-09, global = 7.56067e-10, cumulative = 6.4181e-06
GAMG: Solving for p, Initial residual = 0.000383012, Final residual = 9.61895e-07, No Iterations 19
time step continuity errors : sum local = 1.86361e-10, global = -1.38586e-11, cumulative = 6.41808e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000340392, Final residual = 7.31171e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000419025, Final residual = 7.5361e-06, No Iterations 5
ExecutionTime = 41.5 s ClockTime = 42 s
Time = 3.9275
Courant Number mean: 0.113053 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.9008e-05, Final residual = 9.16122e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000175403, Final residual = 8.57588e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000531685, Final residual = 4.01727e-05, No Iterations 7
time step continuity errors : sum local = 7.78411e-09, global = 7.66147e-10, cumulative = 6.41885e-06
GAMG: Solving for p, Initial residual = 0.000378918, Final residual = 9.939e-07, No Iterations 19
time step continuity errors : sum local = 1.92564e-10, global = -1.46852e-11, cumulative = 6.41884e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000339735, Final residual = 7.29943e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000418414, Final residual = 7.48786e-06, No Iterations 5
ExecutionTime = 41.53 s ClockTime = 42 s
Time = 3.93
Courant Number mean: 0.113052 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.84797e-05, Final residual = 9.10432e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000174029, Final residual = 8.49435e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000525616, Final residual = 3.98317e-05, No Iterations 7
time step continuity errors : sum local = 7.71798e-09, global = 7.78663e-10, cumulative = 6.41961e-06
GAMG: Solving for p, Initial residual = 0.000374923, Final residual = 6.36208e-07, No Iterations 21
time step continuity errors : sum local = 1.23264e-10, global = -9.86603e-12, cumulative = 6.4196e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000339085, Final residual = 7.28786e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000417847, Final residual = 7.44037e-06, No Iterations 5
ExecutionTime = 41.56 s ClockTime = 42 s
Time = 3.9325
Courant Number mean: 0.11305 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.79563e-05, Final residual = 9.04763e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000172673, Final residual = 8.4137e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000527909, Final residual = 3.95872e-05, No Iterations 7
time step continuity errors : sum local = 7.67055e-09, global = 7.92981e-10, cumulative = 6.4204e-06
GAMG: Solving for p, Initial residual = 0.000371316, Final residual = 6.86005e-07, No Iterations 21
time step continuity errors : sum local = 1.32914e-10, global = -1.15911e-11, cumulative = 6.42039e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000338446, Final residual = 7.27846e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000417279, Final residual = 7.39449e-06, No Iterations 5
ExecutionTime = 41.59 s ClockTime = 42 s
Time = 3.935
Courant Number mean: 0.113049 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.74387e-05, Final residual = 8.99182e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000171322, Final residual = 8.33455e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000552304, Final residual = 3.91989e-05, No Iterations 7
time step continuity errors : sum local = 7.59526e-09, global = 8.08195e-10, cumulative = 6.42119e-06
GAMG: Solving for p, Initial residual = 0.000368088, Final residual = 7.48576e-07, No Iterations 21
time step continuity errors : sum local = 1.4504e-10, global = -1.4273e-11, cumulative = 6.42118e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000337811, Final residual = 7.27103e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000416711, Final residual = 7.34904e-06, No Iterations 5
ExecutionTime = 41.62 s ClockTime = 42 s
Time = 3.9375
Courant Number mean: 0.113048 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.69293e-05, Final residual = 8.93604e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000170005, Final residual = 8.25622e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000550736, Final residual = 3.89532e-05, No Iterations 7
time step continuity errors : sum local = 7.54765e-09, global = 8.2536e-10, cumulative = 6.42201e-06
GAMG: Solving for p, Initial residual = 0.000364917, Final residual = 8.3043e-07, No Iterations 21
time step continuity errors : sum local = 1.60901e-10, global = -1.82833e-11, cumulative = 6.42199e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00033721, Final residual = 7.26694e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000416142, Final residual = 7.30579e-06, No Iterations 5
ExecutionTime = 41.65 s ClockTime = 42 s
Time = 3.94
Courant Number mean: 0.113047 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.64245e-05, Final residual = 8.88052e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000168694, Final residual = 8.17918e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000544384, Final residual = 3.87292e-05, No Iterations 7
time step continuity errors : sum local = 7.50423e-09, global = 8.44757e-10, cumulative = 6.42283e-06
GAMG: Solving for p, Initial residual = 0.000361615, Final residual = 9.30775e-07, No Iterations 21
time step continuity errors : sum local = 1.80346e-10, global = -2.37467e-11, cumulative = 6.42281e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000336644, Final residual = 7.26527e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000415573, Final residual = 7.26574e-06, No Iterations 5
ExecutionTime = 41.68 s ClockTime = 42 s
Time = 3.9425
Courant Number mean: 0.113046 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.59234e-05, Final residual = 8.82538e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000167401, Final residual = 8.10299e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000540204, Final residual = 3.85399e-05, No Iterations 7
time step continuity errors : sum local = 7.46753e-09, global = 8.65788e-10, cumulative = 6.42367e-06
GAMG: Solving for p, Initial residual = 0.000358444, Final residual = 8.76622e-07, No Iterations 22
time step continuity errors : sum local = 1.69856e-10, global = 2.38557e-11, cumulative = 6.4237e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000336072, Final residual = 7.26371e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00041503, Final residual = 7.23371e-06, No Iterations 5
ExecutionTime = 41.7 s ClockTime = 42 s
Time = 3.945
Courant Number mean: 0.113045 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.54257e-05, Final residual = 8.77097e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000166122, Final residual = 8.0276e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000531911, Final residual = 3.82583e-05, No Iterations 7
time step continuity errors : sum local = 7.41298e-09, global = 8.86268e-10, cumulative = 6.42458e-06
GAMG: Solving for p, Initial residual = 0.000355579, Final residual = 9.05946e-07, No Iterations 22
time step continuity errors : sum local = 1.7554e-10, global = 2.35682e-11, cumulative = 6.42461e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000335513, Final residual = 7.26263e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000414533, Final residual = 7.20334e-06, No Iterations 5
ExecutionTime = 41.73 s ClockTime = 42 s
Time = 3.9475
Courant Number mean: 0.113044 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.49321e-05, Final residual = 8.71685e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000164862, Final residual = 7.9534e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000552656, Final residual = 3.81329e-05, No Iterations 7
time step continuity errors : sum local = 7.38868e-09, global = 9.12508e-10, cumulative = 6.42552e-06
GAMG: Solving for p, Initial residual = 0.000352786, Final residual = 9.34981e-07, No Iterations 22
time step continuity errors : sum local = 1.8117e-10, global = 2.27856e-11, cumulative = 6.42554e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000334978, Final residual = 7.26261e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000414053, Final residual = 7.17582e-06, No Iterations 5
ExecutionTime = 41.76 s ClockTime = 42 s
Time = 3.95
Courant Number mean: 0.113044 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.44418e-05, Final residual = 8.6628e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000163614, Final residual = 7.87976e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000555762, Final residual = 3.80255e-05, No Iterations 7
time step continuity errors : sum local = 7.36794e-09, global = 9.40181e-10, cumulative = 6.42648e-06
GAMG: Solving for p, Initial residual = 0.000350423, Final residual = 9.6235e-07, No Iterations 22
time step continuity errors : sum local = 1.86478e-10, global = 2.17659e-11, cumulative = 6.42651e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000334449, Final residual = 7.26339e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0004136, Final residual = 7.15125e-06, No Iterations 5
ExecutionTime = 41.79 s ClockTime = 42 s
Time = 3.9525
Courant Number mean: 0.113043 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.39539e-05, Final residual = 8.60886e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000162395, Final residual = 7.80703e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000547957, Final residual = 3.7952e-05, No Iterations 7
time step continuity errors : sum local = 7.35375e-09, global = 9.70877e-10, cumulative = 6.42748e-06
GAMG: Solving for p, Initial residual = 0.000347877, Final residual = 9.85947e-07, No Iterations 22
time step continuity errors : sum local = 1.91055e-10, global = 2.07006e-11, cumulative = 6.4275e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000333929, Final residual = 7.26644e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000413211, Final residual = 7.1271e-06, No Iterations 5
ExecutionTime = 41.82 s ClockTime = 42 s
Time = 3.955
Courant Number mean: 0.113043 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.34756e-05, Final residual = 8.55529e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000161195, Final residual = 7.73515e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00054494, Final residual = 3.78985e-05, No Iterations 7
time step continuity errors : sum local = 7.34346e-09, global = 1.00325e-09, cumulative = 6.4285e-06
GAMG: Solving for p, Initial residual = 0.000345417, Final residual = 6.58033e-07, No Iterations 24
time step continuity errors : sum local = 1.27515e-10, global = 1.19221e-11, cumulative = 6.42851e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000333423, Final residual = 7.27096e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000412838, Final residual = 7.1031e-06, No Iterations 5
ExecutionTime = 41.85 s ClockTime = 42 s
Time = 3.9575
Courant Number mean: 0.113042 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.30031e-05, Final residual = 8.50154e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000160007, Final residual = 7.66397e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000534148, Final residual = 3.81226e-05, No Iterations 7
time step continuity errors : sum local = 7.38695e-09, global = 1.05014e-09, cumulative = 6.42956e-06
GAMG: Solving for p, Initial residual = 0.000343119, Final residual = 6.57236e-07, No Iterations 24
time step continuity errors : sum local = 1.27365e-10, global = 1.16073e-11, cumulative = 6.42957e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00033293, Final residual = 7.2761e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000412462, Final residual = 7.08173e-06, No Iterations 5
ExecutionTime = 41.89 s ClockTime = 42 s
Time = 3.96
Courant Number mean: 0.113042 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.25369e-05, Final residual = 8.44787e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000158812, Final residual = 7.59361e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000517787, Final residual = 3.79785e-05, No Iterations 7
time step continuity errors : sum local = 7.3592e-09, global = 1.07732e-09, cumulative = 6.43065e-06
GAMG: Solving for p, Initial residual = 0.000340794, Final residual = 6.51446e-07, No Iterations 24
time step continuity errors : sum local = 1.26248e-10, global = 1.13059e-11, cumulative = 6.43066e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000332459, Final residual = 7.28403e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000412087, Final residual = 7.06228e-06, No Iterations 5
ExecutionTime = 41.92 s ClockTime = 42 s
Time = 3.9625
Courant Number mean: 0.113041 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.20728e-05, Final residual = 8.39432e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00015764, Final residual = 7.52414e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000510398, Final residual = 3.8162e-05, No Iterations 7
time step continuity errors : sum local = 7.39491e-09, global = 1.1217e-09, cumulative = 6.43178e-06
GAMG: Solving for p, Initial residual = 0.000338787, Final residual = 6.42995e-07, No Iterations 24
time step continuity errors : sum local = 1.24615e-10, global = 1.10536e-11, cumulative = 6.43179e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000331984, Final residual = 7.29434e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000411711, Final residual = 7.04331e-06, No Iterations 5
ExecutionTime = 41.95 s ClockTime = 42 s
Time = 3.965
Courant Number mean: 0.113041 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.16106e-05, Final residual = 8.34111e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000156481, Final residual = 7.4554e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000506302, Final residual = 3.83006e-05, No Iterations 7
time step continuity errors : sum local = 7.42191e-09, global = 1.16072e-09, cumulative = 6.43296e-06
GAMG: Solving for p, Initial residual = 0.000336825, Final residual = 9.94501e-07, No Iterations 22
time step continuity errors : sum local = 1.92744e-10, global = 1.68024e-11, cumulative = 6.43297e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00033152, Final residual = 7.30545e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000411335, Final residual = 7.0282e-06, No Iterations 5
ExecutionTime = 41.98 s ClockTime = 42 s
Time = 3.9675
Courant Number mean: 0.113041 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.11517e-05, Final residual = 8.28859e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00015533, Final residual = 7.38741e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000500837, Final residual = 3.83006e-05, No Iterations 7
time step continuity errors : sum local = 7.42207e-09, global = 1.19421e-09, cumulative = 6.43417e-06
GAMG: Solving for p, Initial residual = 0.000334749, Final residual = 9.77679e-07, No Iterations 22
time step continuity errors : sum local = 1.8949e-10, global = 1.62583e-11, cumulative = 6.43418e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00033107, Final residual = 7.3172e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000410969, Final residual = 7.01709e-06, No Iterations 5
ExecutionTime = 42.01 s ClockTime = 42 s
Time = 3.97
Courant Number mean: 0.113041 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.06976e-05, Final residual = 8.23583e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000154197, Final residual = 7.31972e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000502759, Final residual = 3.884e-05, No Iterations 7
time step continuity errors : sum local = 7.52674e-09, global = 1.2601e-09, cumulative = 6.43544e-06
GAMG: Solving for p, Initial residual = 0.000333343, Final residual = 9.66221e-07, No Iterations 22
time step continuity errors : sum local = 1.87275e-10, global = 1.59226e-11, cumulative = 6.43546e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000330633, Final residual = 7.33071e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000410609, Final residual = 7.01262e-06, No Iterations 5
ExecutionTime = 42.03 s ClockTime = 42 s
Time = 3.9725
Courant Number mean: 0.113041 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 7.02507e-05, Final residual = 8.18309e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000153059, Final residual = 7.25272e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000488897, Final residual = 3.88971e-05, No Iterations 7
time step continuity errors : sum local = 7.53787e-09, global = 1.28942e-09, cumulative = 6.43675e-06
GAMG: Solving for p, Initial residual = 0.000331295, Final residual = 9.38997e-07, No Iterations 22
time step continuity errors : sum local = 1.82001e-10, global = 1.53475e-11, cumulative = 6.43676e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00033023, Final residual = 7.34522e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000410271, Final residual = 7.00988e-06, No Iterations 5
ExecutionTime = 42.06 s ClockTime = 42 s
Time = 3.975
Courant Number mean: 0.113041 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.98078e-05, Final residual = 8.13031e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000151951, Final residual = 7.18711e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000472071, Final residual = 3.96307e-05, No Iterations 7
time step continuity errors : sum local = 7.68005e-09, global = 1.35872e-09, cumulative = 6.43812e-06
GAMG: Solving for p, Initial residual = 0.000329922, Final residual = 9.15487e-07, No Iterations 22
time step continuity errors : sum local = 1.7745e-10, global = 1.48853e-11, cumulative = 6.43814e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000329838, Final residual = 7.36294e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409968, Final residual = 7.00789e-06, No Iterations 5
ExecutionTime = 42.09 s ClockTime = 42 s
Time = 3.9775
Courant Number mean: 0.113041 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.93685e-05, Final residual = 8.07775e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000150846, Final residual = 7.12146e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000465859, Final residual = 3.99188e-05, No Iterations 7
time step continuity errors : sum local = 7.73602e-09, global = 1.40423e-09, cumulative = 6.43954e-06
GAMG: Solving for p, Initial residual = 0.000328644, Final residual = 8.89573e-07, No Iterations 22
time step continuity errors : sum local = 1.72432e-10, global = 1.44227e-11, cumulative = 6.43956e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000329452, Final residual = 7.38097e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409735, Final residual = 7.00761e-06, No Iterations 5
ExecutionTime = 42.12 s ClockTime = 42 s
Time = 3.98
Courant Number mean: 0.113041 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.89325e-05, Final residual = 8.02521e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000149759, Final residual = 7.05663e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000456492, Final residual = 4.02987e-05, No Iterations 7
time step continuity errors : sum local = 7.80972e-09, global = 1.45436e-09, cumulative = 6.44101e-06
GAMG: Solving for p, Initial residual = 0.00032728, Final residual = 8.62473e-07, No Iterations 22
time step continuity errors : sum local = 1.67183e-10, global = 1.39605e-11, cumulative = 6.44102e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00032907, Final residual = 7.40129e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409538, Final residual = 7.01249e-06, No Iterations 5
ExecutionTime = 42.15 s ClockTime = 42 s
Time = 3.9825
Courant Number mean: 0.113041 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.84984e-05, Final residual = 7.97284e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000148683, Final residual = 6.99267e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000443324, Final residual = 4.07089e-05, No Iterations 7
time step continuity errors : sum local = 7.88927e-09, global = 1.50235e-09, cumulative = 6.44253e-06
GAMG: Solving for p, Initial residual = 0.000325975, Final residual = 8.34236e-07, No Iterations 22
time step continuity errors : sum local = 1.61714e-10, global = 1.34907e-11, cumulative = 6.44254e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000328695, Final residual = 7.42168e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409344, Final residual = 7.01929e-06, No Iterations 5
ExecutionTime = 42.18 s ClockTime = 42 s
Time = 3.985
Courant Number mean: 0.113041 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.80643e-05, Final residual = 7.92068e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000147623, Final residual = 6.92955e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000435417, Final residual = 4.11779e-05, No Iterations 7
time step continuity errors : sum local = 7.98024e-09, global = 1.55032e-09, cumulative = 6.44409e-06
GAMG: Solving for p, Initial residual = 0.000324942, Final residual = 8.05048e-07, No Iterations 22
time step continuity errors : sum local = 1.5606e-10, global = 1.30112e-11, cumulative = 6.4441e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00032833, Final residual = 7.44356e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409156, Final residual = 7.02823e-06, No Iterations 5
ExecutionTime = 42.2 s ClockTime = 42 s
Time = 3.9875
Courant Number mean: 0.113042 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.76335e-05, Final residual = 7.86855e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000146574, Final residual = 6.86709e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000428123, Final residual = 4.17395e-05, No Iterations 7
time step continuity errors : sum local = 8.08916e-09, global = 1.59629e-09, cumulative = 6.4457e-06
GAMG: Solving for p, Initial residual = 0.000324013, Final residual = 7.75298e-07, No Iterations 22
time step continuity errors : sum local = 1.50297e-10, global = 1.25215e-11, cumulative = 6.44571e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000327979, Final residual = 7.46608e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408976, Final residual = 7.04422e-06, No Iterations 5
ExecutionTime = 42.24 s ClockTime = 43 s
Time = 3.99
Courant Number mean: 0.113042 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.72088e-05, Final residual = 7.81655e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00014554, Final residual = 6.80531e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000421951, Final residual = 2.55892e-05, No Iterations 8
time step continuity errors : sum local = 4.95926e-09, global = -6.49103e-10, cumulative = 6.44506e-06
GAMG: Solving for p, Initial residual = 0.000320405, Final residual = 6.99225e-07, No Iterations 21
time step continuity errors : sum local = 1.35552e-10, global = 1.11517e-11, cumulative = 6.44507e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000327639, Final residual = 7.48946e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408813, Final residual = 7.06091e-06, No Iterations 5
ExecutionTime = 42.26 s ClockTime = 43 s
Time = 3.9925
Courant Number mean: 0.113042 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.6783e-05, Final residual = 7.76296e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.0001446, Final residual = 6.74544e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000425751, Final residual = 4.04128e-05, No Iterations 6
time step continuity errors : sum local = 7.83224e-09, global = -1.04845e-09, cumulative = 6.44403e-06
GAMG: Solving for p, Initial residual = 0.000313582, Final residual = 7.74028e-07, No Iterations 21
time step continuity errors : sum local = 1.50043e-10, global = 1.19776e-11, cumulative = 6.44404e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000327301, Final residual = 7.51405e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408668, Final residual = 7.07983e-06, No Iterations 5
ExecutionTime = 42.29 s ClockTime = 43 s
Time = 3.995
Courant Number mean: 0.113043 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.63657e-05, Final residual = 7.71418e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000143398, Final residual = 6.68494e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000402791, Final residual = 3.76206e-05, No Iterations 6
time step continuity errors : sum local = 7.29142e-09, global = -9.87875e-10, cumulative = 6.44305e-06
GAMG: Solving for p, Initial residual = 0.000300388, Final residual = 7.32692e-07, No Iterations 21
time step continuity errors : sum local = 1.42033e-10, global = 1.14584e-11, cumulative = 6.44306e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000326966, Final residual = 7.53969e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00040857, Final residual = 7.1003e-06, No Iterations 5
ExecutionTime = 42.32 s ClockTime = 43 s
Time = 3.9975
Courant Number mean: 0.113043 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.59512e-05, Final residual = 7.66184e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000142422, Final residual = 6.62222e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000401603, Final residual = 3.70645e-05, No Iterations 6
time step continuity errors : sum local = 7.18354e-09, global = -9.25881e-10, cumulative = 6.44214e-06
GAMG: Solving for p, Initial residual = 0.000300647, Final residual = 7.0422e-07, No Iterations 21
time step continuity errors : sum local = 1.36516e-10, global = 1.08955e-11, cumulative = 6.44215e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000326632, Final residual = 7.56597e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408498, Final residual = 7.12355e-06, No Iterations 5
ExecutionTime = 42.34 s ClockTime = 43 s
Time = 4
Courant Number mean: 0.113044 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.5537e-05, Final residual = 7.61022e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000141452, Final residual = 6.56442e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000402012, Final residual = 3.63794e-05, No Iterations 6
time step continuity errors : sum local = 7.05076e-09, global = -9.00806e-10, cumulative = 6.44125e-06
GAMG: Solving for p, Initial residual = 0.00029949, Final residual = 6.72826e-07, No Iterations 21
time step continuity errors : sum local = 1.30429e-10, global = 1.03627e-11, cumulative = 6.44126e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000326301, Final residual = 7.59381e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408423, Final residual = 7.14694e-06, No Iterations 5
ExecutionTime = 42.4 s ClockTime = 43 s
Time = 4.0025
Courant Number mean: 0.113044 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.51261e-05, Final residual = 7.55857e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000140485, Final residual = 6.50446e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000395393, Final residual = 3.56054e-05, No Iterations 6
time step continuity errors : sum local = 6.90067e-09, global = -8.49444e-10, cumulative = 6.44041e-06
GAMG: Solving for p, Initial residual = 0.00029881, Final residual = 6.40925e-07, No Iterations 21
time step continuity errors : sum local = 1.24247e-10, global = 9.7994e-12, cumulative = 6.44042e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000325975, Final residual = 7.62386e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408343, Final residual = 7.17225e-06, No Iterations 5
ExecutionTime = 42.44 s ClockTime = 43 s
Time = 4.005
Courant Number mean: 0.113045 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.4718e-05, Final residual = 7.50705e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000139538, Final residual = 6.44661e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.0003905, Final residual = 3.5002e-05, No Iterations 6
time step continuity errors : sum local = 6.7837e-09, global = -8.08779e-10, cumulative = 6.43961e-06
GAMG: Solving for p, Initial residual = 0.000298233, Final residual = 6.12667e-07, No Iterations 21
time step continuity errors : sum local = 1.1877e-10, global = 9.31986e-12, cumulative = 6.43962e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000325653, Final residual = 7.65468e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408261, Final residual = 7.2018e-06, No Iterations 5
ExecutionTime = 42.47 s ClockTime = 43 s
Time = 4.0075
Courant Number mean: 0.113046 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.43146e-05, Final residual = 7.45565e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000138589, Final residual = 6.38829e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00038779, Final residual = 3.42969e-05, No Iterations 6
time step continuity errors : sum local = 6.64704e-09, global = -7.61008e-10, cumulative = 6.43886e-06
GAMG: Solving for p, Initial residual = 0.000297758, Final residual = 9.90221e-07, No Iterations 19
time step continuity errors : sum local = 1.91965e-10, global = 1.44714e-11, cumulative = 6.43887e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000325335, Final residual = 7.68559e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408179, Final residual = 7.23198e-06, No Iterations 5
ExecutionTime = 42.5 s ClockTime = 43 s
Time = 4.01
Courant Number mean: 0.113046 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.39145e-05, Final residual = 7.40458e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000137647, Final residual = 6.33106e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000385669, Final residual = 3.3517e-05, No Iterations 6
time step continuity errors : sum local = 6.49588e-09, global = -7.15625e-10, cumulative = 6.43815e-06
GAMG: Solving for p, Initial residual = 0.000297177, Final residual = 9.44499e-07, No Iterations 19
time step continuity errors : sum local = 1.83104e-10, global = 1.37364e-11, cumulative = 6.43817e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000325026, Final residual = 7.71807e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408099, Final residual = 7.26444e-06, No Iterations 5
ExecutionTime = 42.53 s ClockTime = 43 s
Time = 4.0125
Courant Number mean: 0.113047 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.35169e-05, Final residual = 7.35323e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00013672, Final residual = 6.27387e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000383337, Final residual = 3.32882e-05, No Iterations 6
time step continuity errors : sum local = 6.45153e-09, global = -6.71279e-10, cumulative = 6.4375e-06
GAMG: Solving for p, Initial residual = 0.000297297, Final residual = 8.99919e-07, No Iterations 19
time step continuity errors : sum local = 1.74466e-10, global = 1.30021e-11, cumulative = 6.43751e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000324726, Final residual = 7.75086e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408023, Final residual = 7.29842e-06, No Iterations 5
ExecutionTime = 42.56 s ClockTime = 43 s
Time = 4.015
Courant Number mean: 0.113048 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.31218e-05, Final residual = 7.30195e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000135799, Final residual = 6.21756e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000380621, Final residual = 3.30922e-05, No Iterations 6
time step continuity errors : sum local = 6.41356e-09, global = -6.25183e-10, cumulative = 6.43689e-06
GAMG: Solving for p, Initial residual = 0.000297468, Final residual = 8.56153e-07, No Iterations 19
time step continuity errors : sum local = 1.65985e-10, global = 1.22938e-11, cumulative = 6.4369e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000324418, Final residual = 7.78428e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000407954, Final residual = 7.3396e-06, No Iterations 5
ExecutionTime = 42.58 s ClockTime = 43 s
Time = 4.0175
Courant Number mean: 0.113049 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.27281e-05, Final residual = 7.25061e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000134884, Final residual = 6.1616e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000379154, Final residual = 3.29754e-05, No Iterations 6
time step continuity errors : sum local = 6.3909e-09, global = -5.88746e-10, cumulative = 6.43631e-06
GAMG: Solving for p, Initial residual = 0.000297975, Final residual = 8.14119e-07, No Iterations 19
time step continuity errors : sum local = 1.57838e-10, global = 1.1582e-11, cumulative = 6.43632e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000324119, Final residual = 7.81938e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0004079, Final residual = 7.38647e-06, No Iterations 5
ExecutionTime = 42.61 s ClockTime = 43 s
Time = 4.02
Courant Number mean: 0.113049 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.23377e-05, Final residual = 7.19964e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000133985, Final residual = 6.10625e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000378578, Final residual = 3.28154e-05, No Iterations 6
time step continuity errors : sum local = 6.35978e-09, global = -5.50913e-10, cumulative = 6.43577e-06
GAMG: Solving for p, Initial residual = 0.000298541, Final residual = 7.7363e-07, No Iterations 19
time step continuity errors : sum local = 1.49989e-10, global = 1.09167e-11, cumulative = 6.43578e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000323823, Final residual = 7.85584e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000407867, Final residual = 7.43647e-06, No Iterations 5
ExecutionTime = 42.64 s ClockTime = 43 s
Time = 4.0225
Courant Number mean: 0.11305 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.19508e-05, Final residual = 7.1488e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000133101, Final residual = 6.05103e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000375453, Final residual = 3.25072e-05, No Iterations 6
time step continuity errors : sum local = 6.29993e-09, global = -5.10612e-10, cumulative = 6.43527e-06
GAMG: Solving for p, Initial residual = 0.000299281, Final residual = 7.35678e-07, No Iterations 19
time step continuity errors : sum local = 1.42632e-10, global = 1.02894e-11, cumulative = 6.43528e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000323493, Final residual = 7.89166e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000407865, Final residual = 7.48861e-06, No Iterations 5
ExecutionTime = 42.67 s ClockTime = 43 s
Time = 4.025
Courant Number mean: 0.113051 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.15649e-05, Final residual = 7.0981e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000132222, Final residual = 5.99652e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000372739, Final residual = 3.05721e-05, No Iterations 6
time step continuity errors : sum local = 5.92481e-09, global = -5.36719e-10, cumulative = 6.43474e-06
GAMG: Solving for p, Initial residual = 0.000298424, Final residual = 7.25538e-07, No Iterations 19
time step continuity errors : sum local = 1.40666e-10, global = 1.00953e-11, cumulative = 6.43475e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000323211, Final residual = 7.93e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000407906, Final residual = 7.5433e-06, No Iterations 5
ExecutionTime = 42.7 s ClockTime = 43 s
Time = 4.0275
Courant Number mean: 0.113052 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.11817e-05, Final residual = 7.0475e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000131348, Final residual = 5.94232e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000369833, Final residual = 2.9222e-05, No Iterations 6
time step continuity errors : sum local = 5.66313e-09, global = -5.27069e-10, cumulative = 6.43423e-06
GAMG: Solving for p, Initial residual = 0.000298195, Final residual = 7.02841e-07, No Iterations 19
time step continuity errors : sum local = 1.36266e-10, global = 9.69486e-12, cumulative = 6.43424e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000322942, Final residual = 7.96719e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000407953, Final residual = 7.60515e-06, No Iterations 5
ExecutionTime = 42.73 s ClockTime = 43 s
Time = 4.03
Courant Number mean: 0.113053 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.08008e-05, Final residual = 6.99684e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000130482, Final residual = 5.88836e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000367539, Final residual = 2.71818e-05, No Iterations 6
time step continuity errors : sum local = 5.26771e-09, global = -5.84906e-10, cumulative = 6.43365e-06
GAMG: Solving for p, Initial residual = 0.000297523, Final residual = 7.13397e-07, No Iterations 19
time step continuity errors : sum local = 1.38311e-10, global = 9.81651e-12, cumulative = 6.43366e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000322677, Final residual = 8.00504e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408002, Final residual = 7.66671e-06, No Iterations 5
ExecutionTime = 42.76 s ClockTime = 43 s
Time = 4.0325
Courant Number mean: 0.113054 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.04218e-05, Final residual = 6.94641e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00012962, Final residual = 5.83513e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000364855, Final residual = 2.43151e-05, No Iterations 6
time step continuity errors : sum local = 4.71216e-09, global = -5.41437e-10, cumulative = 6.43312e-06
GAMG: Solving for p, Initial residual = 0.000299208, Final residual = 7.19476e-07, No Iterations 19
time step continuity errors : sum local = 1.39491e-10, global = 9.89087e-12, cumulative = 6.43313e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000322407, Final residual = 8.04236e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408064, Final residual = 7.72814e-06, No Iterations 5
ExecutionTime = 42.79 s ClockTime = 43 s
Time = 4.035
Courant Number mean: 0.113055 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 6.00463e-05, Final residual = 6.89541e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000128803, Final residual = 5.78257e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000365684, Final residual = 3.56593e-05, No Iterations 5
time step continuity errors : sum local = 6.91054e-09, global = -8.6633e-10, cumulative = 6.43226e-06
GAMG: Solving for p, Initial residual = 0.000292571, Final residual = 6.74784e-07, No Iterations 19
time step continuity errors : sum local = 1.30821e-10, global = 9.09743e-12, cumulative = 6.43227e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000322133, Final residual = 8.07979e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00040815, Final residual = 7.79075e-06, No Iterations 5
ExecutionTime = 42.81 s ClockTime = 43 s
Time = 4.0375
Courant Number mean: 0.113056 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.96777e-05, Final residual = 6.84797e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000127822, Final residual = 5.73087e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000348983, Final residual = 2.19862e-05, No Iterations 7
time step continuity errors : sum local = 4.26087e-09, global = -3.50338e-10, cumulative = 6.43192e-06
GAMG: Solving for p, Initial residual = 0.000291924, Final residual = 5.77239e-07, No Iterations 19
time step continuity errors : sum local = 1.1192e-10, global = 7.63741e-12, cumulative = 6.43193e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000321857, Final residual = 8.11775e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408263, Final residual = 7.85224e-06, No Iterations 5
ExecutionTime = 42.84 s ClockTime = 43 s
Time = 4.04
Courant Number mean: 0.113058 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.93084e-05, Final residual = 6.7944e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000127134, Final residual = 5.67811e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000363294, Final residual = 2.54804e-05, No Iterations 7
time step continuity errors : sum local = 4.9378e-09, global = -4.14334e-10, cumulative = 6.43151e-06
GAMG: Solving for p, Initial residual = 0.000303333, Final residual = 5.60581e-07, No Iterations 19
time step continuity errors : sum local = 1.08694e-10, global = 7.08255e-12, cumulative = 6.43152e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00032158, Final residual = 8.15612e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408382, Final residual = 7.91634e-06, No Iterations 5
ExecutionTime = 42.87 s ClockTime = 43 s
Time = 4.0425
Courant Number mean: 0.113059 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.89435e-05, Final residual = 6.74541e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000126283, Final residual = 5.62982e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000359736, Final residual = 2.51035e-05, No Iterations 7
time step continuity errors : sum local = 4.86482e-09, global = -4.17506e-10, cumulative = 6.4311e-06
GAMG: Solving for p, Initial residual = 0.00030041, Final residual = 5.44932e-07, No Iterations 19
time step continuity errors : sum local = 1.05659e-10, global = 6.78804e-12, cumulative = 6.43111e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0003213, Final residual = 8.19404e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408489, Final residual = 7.9792e-06, No Iterations 5
ExecutionTime = 42.89 s ClockTime = 43 s
Time = 4.045
Courant Number mean: 0.11306 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.85813e-05, Final residual = 6.69594e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000125441, Final residual = 9.98908e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000353025, Final residual = 2.78895e-05, No Iterations 7
time step continuity errors : sum local = 5.40465e-09, global = -4.45116e-10, cumulative = 6.43067e-06
GAMG: Solving for p, Initial residual = 0.000281935, Final residual = 5.33622e-07, No Iterations 19
time step continuity errors : sum local = 1.03464e-10, global = 5.5539e-12, cumulative = 6.43067e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000321017, Final residual = 8.23349e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408579, Final residual = 8.04073e-06, No Iterations 5
ExecutionTime = 42.92 s ClockTime = 43 s
Time = 4.0475
Courant Number mean: 0.113061 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.81613e-05, Final residual = 6.63935e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000125534, Final residual = 5.68085e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.00034197, Final residual = 2.26357e-05, No Iterations 7
time step continuity errors : sum local = 4.38673e-09, global = -4.00949e-10, cumulative = 6.43027e-06
GAMG: Solving for p, Initial residual = 0.000292918, Final residual = 6.37746e-07, No Iterations 19
time step continuity errors : sum local = 1.23656e-10, global = 8.41166e-12, cumulative = 6.43028e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000320734, Final residual = 8.27262e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408663, Final residual = 8.10425e-06, No Iterations 5
ExecutionTime = 42.94 s ClockTime = 43 s
Time = 4.05
Courant Number mean: 0.113062 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.78802e-05, Final residual = 6.59774e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000123513, Final residual = 9.72785e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00037777, Final residual = 3.0764e-05, No Iterations 7
time step continuity errors : sum local = 5.96154e-09, global = -4.70352e-10, cumulative = 6.42981e-06
GAMG: Solving for p, Initial residual = 0.000293566, Final residual = 9.89062e-07, No Iterations 17
time step continuity errors : sum local = 1.91776e-10, global = 1.00756e-11, cumulative = 6.42982e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000320452, Final residual = 8.31342e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408734, Final residual = 8.16511e-06, No Iterations 5
ExecutionTime = 42.97 s ClockTime = 43 s
Time = 4.0525
Courant Number mean: 0.113064 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.74377e-05, Final residual = 6.53985e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000124052, Final residual = 5.61224e-06, No Iterations 4
GAMG: Solving for p, Initial residual = 0.000335861, Final residual = 2.43094e-05, No Iterations 7
time step continuity errors : sum local = 4.71119e-09, global = -4.97739e-10, cumulative = 6.42932e-06
GAMG: Solving for p, Initial residual = 0.000286834, Final residual = 6.36577e-07, No Iterations 19
time step continuity errors : sum local = 1.23428e-10, global = 8.34314e-12, cumulative = 6.42933e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000320174, Final residual = 8.35479e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408799, Final residual = 8.22748e-06, No Iterations 5
ExecutionTime = 42.99 s ClockTime = 43 s
Time = 4.055
Courant Number mean: 0.113065 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.71778e-05, Final residual = 6.49987e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000121804, Final residual = 9.53855e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000377708, Final residual = 3.13422e-05, No Iterations 7
time step continuity errors : sum local = 6.07364e-09, global = -4.76041e-10, cumulative = 6.42885e-06
GAMG: Solving for p, Initial residual = 0.000292407, Final residual = 9.36847e-07, No Iterations 17
time step continuity errors : sum local = 1.81656e-10, global = 9.3711e-12, cumulative = 6.42886e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00031991, Final residual = 8.39563e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408852, Final residual = 8.28936e-06, No Iterations 5
ExecutionTime = 43.02 s ClockTime = 43 s
Time = 4.0575
Courant Number mean: 0.113066 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.67358e-05, Final residual = 6.44118e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000122496, Final residual = 9.85804e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000309368, Final residual = 2.27296e-05, No Iterations 7
time step continuity errors : sum local = 4.40506e-09, global = -3.73599e-10, cumulative = 6.42849e-06
GAMG: Solving for p, Initial residual = 0.000253619, Final residual = 7.31516e-07, No Iterations 17
time step continuity errors : sum local = 1.41838e-10, global = 7.10602e-12, cumulative = 6.4285e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000319652, Final residual = 8.43493e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408897, Final residual = 8.35183e-06, No Iterations 5
ExecutionTime = 43.04 s ClockTime = 43 s
Time = 4.06
Courant Number mean: 0.113068 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.64226e-05, Final residual = 6.39397e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000121152, Final residual = 9.61407e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000330551, Final residual = 2.5576e-05, No Iterations 7
time step continuity errors : sum local = 4.95641e-09, global = -3.98316e-10, cumulative = 6.4281e-06
GAMG: Solving for p, Initial residual = 0.000266874, Final residual = 7.35033e-07, No Iterations 17
time step continuity errors : sum local = 1.42527e-10, global = 7.00067e-12, cumulative = 6.42811e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000319385, Final residual = 8.47397e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408939, Final residual = 8.41612e-06, No Iterations 5
ExecutionTime = 43.07 s ClockTime = 43 s
Time = 4.0625
Courant Number mean: 0.113069 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.60597e-05, Final residual = 6.34335e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000120651, Final residual = 9.61497e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000320709, Final residual = 2.38896e-05, No Iterations 7
time step continuity errors : sum local = 4.62982e-09, global = -3.82275e-10, cumulative = 6.42772e-06
GAMG: Solving for p, Initial residual = 0.000259277, Final residual = 6.96929e-07, No Iterations 17
time step continuity errors : sum local = 1.35138e-10, global = 6.57353e-12, cumulative = 6.42773e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000319107, Final residual = 8.51188e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408977, Final residual = 8.48089e-06, No Iterations 5
ExecutionTime = 43.09 s ClockTime = 43 s
Time = 4.065
Courant Number mean: 0.113071 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.57242e-05, Final residual = 6.29492e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000119768, Final residual = 9.50017e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00031963, Final residual = 2.48658e-05, No Iterations 7
time step continuity errors : sum local = 4.81895e-09, global = -3.72691e-10, cumulative = 6.42736e-06
GAMG: Solving for p, Initial residual = 0.000260979, Final residual = 6.68837e-07, No Iterations 17
time step continuity errors : sum local = 1.29695e-10, global = 6.24507e-12, cumulative = 6.42736e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00031882, Final residual = 8.54838e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409012, Final residual = 8.5476e-06, No Iterations 5
ExecutionTime = 43.11 s ClockTime = 43 s
Time = 4.0675
Courant Number mean: 0.113072 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.53801e-05, Final residual = 6.2455e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000119083, Final residual = 9.44296e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000314874, Final residual = 2.45864e-05, No Iterations 7
time step continuity errors : sum local = 4.7649e-09, global = -3.66521e-10, cumulative = 6.427e-06
GAMG: Solving for p, Initial residual = 0.000258474, Final residual = 6.44439e-07, No Iterations 17
time step continuity errors : sum local = 1.24966e-10, global = 5.9768e-12, cumulative = 6.427e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000318522, Final residual = 8.58394e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409049, Final residual = 8.61905e-06, No Iterations 5
ExecutionTime = 43.14 s ClockTime = 43 s
Time = 4.07
Courant Number mean: 0.113074 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.50453e-05, Final residual = 6.19712e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000118309, Final residual = 9.35708e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000314678, Final residual = 2.4982e-05, No Iterations 7
time step continuity errors : sum local = 4.84159e-09, global = -3.60171e-10, cumulative = 6.42664e-06
GAMG: Solving for p, Initial residual = 0.000258165, Final residual = 6.23027e-07, No Iterations 17
time step continuity errors : sum local = 1.20817e-10, global = 5.74207e-12, cumulative = 6.42665e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000318215, Final residual = 8.61852e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409101, Final residual = 8.69022e-06, No Iterations 5
ExecutionTime = 43.17 s ClockTime = 43 s
Time = 4.0725
Courant Number mean: 0.113075 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.47086e-05, Final residual = 6.14856e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000117591, Final residual = 9.28657e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000312056, Final residual = 2.50286e-05, No Iterations 7
time step continuity errors : sum local = 4.85071e-09, global = -3.5547e-10, cumulative = 6.42629e-06
GAMG: Solving for p, Initial residual = 0.000256699, Final residual = 6.09245e-07, No Iterations 17
time step continuity errors : sum local = 1.18146e-10, global = 5.54084e-12, cumulative = 6.4263e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000317897, Final residual = 8.65217e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409188, Final residual = 8.76184e-06, No Iterations 5
ExecutionTime = 43.2 s ClockTime = 43 s
Time = 4.075
Courant Number mean: 0.113077 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.43757e-05, Final residual = 6.10033e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000116852, Final residual = 9.20879e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000312305, Final residual = 2.52728e-05, No Iterations 7
time step continuity errors : sum local = 4.89811e-09, global = -3.51364e-10, cumulative = 6.42595e-06
GAMG: Solving for p, Initial residual = 0.000255867, Final residual = 5.99265e-07, No Iterations 17
time step continuity errors : sum local = 1.16214e-10, global = 5.36444e-12, cumulative = 6.42595e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00031757, Final residual = 8.68479e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409292, Final residual = 8.83231e-06, No Iterations 5
ExecutionTime = 43.22 s ClockTime = 43 s
Time = 4.0775
Courant Number mean: 0.113078 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.40444e-05, Final residual = 6.05248e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000116133, Final residual = 9.13576e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000308468, Final residual = 2.54206e-05, No Iterations 7
time step continuity errors : sum local = 4.92682e-09, global = -3.48077e-10, cumulative = 6.4256e-06
GAMG: Solving for p, Initial residual = 0.00025457, Final residual = 5.92172e-07, No Iterations 17
time step continuity errors : sum local = 1.1484e-10, global = 5.20914e-12, cumulative = 6.42561e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000317231, Final residual = 8.71794e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409384, Final residual = 8.9015e-06, No Iterations 5
ExecutionTime = 43.24 s ClockTime = 44 s
Time = 4.08
Courant Number mean: 0.11308 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.37158e-05, Final residual = 6.00483e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000115411, Final residual = 9.06094e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000306988, Final residual = 2.56212e-05, No Iterations 7
time step continuity errors : sum local = 4.96577e-09, global = -3.45118e-10, cumulative = 6.42526e-06
GAMG: Solving for p, Initial residual = 0.000253496, Final residual = 5.86015e-07, No Iterations 17
time step continuity errors : sum local = 1.13649e-10, global = 5.07299e-12, cumulative = 6.42527e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000316895, Final residual = 8.74906e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409466, Final residual = 8.96911e-06, No Iterations 5
ExecutionTime = 43.27 s ClockTime = 44 s
Time = 4.0825
Courant Number mean: 0.113081 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.33896e-05, Final residual = 5.95727e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000114698, Final residual = 8.98766e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000306351, Final residual = 2.57908e-05, No Iterations 7
time step continuity errors : sum local = 4.99872e-09, global = -3.42581e-10, cumulative = 6.42493e-06
GAMG: Solving for p, Initial residual = 0.000252387, Final residual = 5.8088e-07, No Iterations 17
time step continuity errors : sum local = 1.12655e-10, global = 4.95343e-12, cumulative = 6.42493e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000316536, Final residual = 8.77886e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409541, Final residual = 9.03386e-06, No Iterations 5
ExecutionTime = 43.3 s ClockTime = 44 s
Time = 4.085
Courant Number mean: 0.113083 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.30651e-05, Final residual = 5.91015e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000113987, Final residual = 8.91432e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000308527, Final residual = 2.59641e-05, No Iterations 7
time step continuity errors : sum local = 5.03239e-09, global = -3.42314e-10, cumulative = 6.42459e-06
GAMG: Solving for p, Initial residual = 0.000251552, Final residual = 5.77063e-07, No Iterations 17
time step continuity errors : sum local = 1.11917e-10, global = 4.85274e-12, cumulative = 6.42459e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000316168, Final residual = 8.80774e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409617, Final residual = 9.09812e-06, No Iterations 5
ExecutionTime = 43.32 s ClockTime = 44 s
Time = 4.0875
Courant Number mean: 0.113084 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.2741e-05, Final residual = 5.86317e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000113291, Final residual = 8.84207e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000307568, Final residual = 2.6701e-05, No Iterations 7
time step continuity errors : sum local = 5.1753e-09, global = -3.23717e-10, cumulative = 6.42427e-06
GAMG: Solving for p, Initial residual = 0.000251572, Final residual = 5.71264e-07, No Iterations 17
time step continuity errors : sum local = 1.10795e-10, global = 4.73196e-12, cumulative = 6.42428e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000315791, Final residual = 8.83674e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409713, Final residual = 9.1618e-06, No Iterations 5
ExecutionTime = 43.35 s ClockTime = 44 s
Time = 4.09
Courant Number mean: 0.113086 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.24217e-05, Final residual = 5.81643e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000112574, Final residual = 8.76997e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000300559, Final residual = 2.68667e-05, No Iterations 7
time step continuity errors : sum local = 5.20754e-09, global = -3.23652e-10, cumulative = 6.42395e-06
GAMG: Solving for p, Initial residual = 0.0002497, Final residual = 5.69578e-07, No Iterations 17
time step continuity errors : sum local = 1.10471e-10, global = 4.66659e-12, cumulative = 6.42396e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000315404, Final residual = 8.86544e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409804, Final residual = 9.22432e-06, No Iterations 5
ExecutionTime = 43.37 s ClockTime = 44 s
Time = 4.0925
Courant Number mean: 0.113088 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.21027e-05, Final residual = 5.77006e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000111881, Final residual = 8.69941e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000299094, Final residual = 2.69922e-05, No Iterations 7
time step continuity errors : sum local = 5.23196e-09, global = -3.22663e-10, cumulative = 6.42363e-06
GAMG: Solving for p, Initial residual = 0.000248538, Final residual = 5.6741e-07, No Iterations 17
time step continuity errors : sum local = 1.10053e-10, global = 4.59939e-12, cumulative = 6.42364e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000315009, Final residual = 8.89176e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409876, Final residual = 9.28565e-06, No Iterations 5
ExecutionTime = 43.4 s ClockTime = 44 s
Time = 4.095
Courant Number mean: 0.113089 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.17858e-05, Final residual = 5.72388e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000111198, Final residual = 8.62923e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000304182, Final residual = 2.71458e-05, No Iterations 7
time step continuity errors : sum local = 5.26186e-09, global = -3.21868e-10, cumulative = 6.42332e-06
GAMG: Solving for p, Initial residual = 0.000247735, Final residual = 5.6577e-07, No Iterations 17
time step continuity errors : sum local = 1.09738e-10, global = 4.54277e-12, cumulative = 6.42332e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000314605, Final residual = 8.91701e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00040993, Final residual = 9.34576e-06, No Iterations 5
ExecutionTime = 43.43 s ClockTime = 44 s
Time = 4.0975
Courant Number mean: 0.113091 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.14736e-05, Final residual = 5.67799e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000110523, Final residual = 8.55985e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00029737, Final residual = 2.72692e-05, No Iterations 7
time step continuity errors : sum local = 5.28588e-09, global = -3.20925e-10, cumulative = 6.423e-06
GAMG: Solving for p, Initial residual = 0.000246366, Final residual = 5.64352e-07, No Iterations 17
time step continuity errors : sum local = 1.09465e-10, global = 4.49349e-12, cumulative = 6.423e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000314191, Final residual = 8.94164e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409966, Final residual = 9.40466e-06, No Iterations 5
ExecutionTime = 43.46 s ClockTime = 44 s
Time = 4.1
Courant Number mean: 0.113093 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.11634e-05, Final residual = 5.6324e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000109852, Final residual = 8.49076e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000294328, Final residual = 2.7394e-05, No Iterations 7
time step continuity errors : sum local = 5.31017e-09, global = -3.20011e-10, cumulative = 6.42268e-06
GAMG: Solving for p, Initial residual = 0.000245224, Final residual = 5.63341e-07, No Iterations 17
time step continuity errors : sum local = 1.09272e-10, global = 4.45274e-12, cumulative = 6.42269e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000313766, Final residual = 8.96595e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409983, Final residual = 9.46233e-06, No Iterations 5
ExecutionTime = 43.52 s ClockTime = 44 s
Time = 4.1025
Courant Number mean: 0.113094 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.08554e-05, Final residual = 5.58708e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000109185, Final residual = 8.42218e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00029208, Final residual = 2.75089e-05, No Iterations 7
time step continuity errors : sum local = 5.33256e-09, global = -3.19104e-10, cumulative = 6.42237e-06
GAMG: Solving for p, Initial residual = 0.000244129, Final residual = 5.62699e-07, No Iterations 17
time step continuity errors : sum local = 1.0915e-10, global = 4.41923e-12, cumulative = 6.42237e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000313333, Final residual = 8.98838e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409981, Final residual = 9.51879e-06, No Iterations 5
ExecutionTime = 43.54 s ClockTime = 44 s
Time = 4.105
Courant Number mean: 0.113096 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.05496e-05, Final residual = 5.54198e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000108524, Final residual = 8.354e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000289264, Final residual = 2.76157e-05, No Iterations 7
time step continuity errors : sum local = 5.35339e-09, global = -3.1818e-10, cumulative = 6.42206e-06
GAMG: Solving for p, Initial residual = 0.000243045, Final residual = 5.62339e-07, No Iterations 17
time step continuity errors : sum local = 1.09083e-10, global = 4.39237e-12, cumulative = 6.42206e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000312892, Final residual = 9.00868e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409961, Final residual = 9.57404e-06, No Iterations 5
ExecutionTime = 43.57 s ClockTime = 44 s
Time = 4.1075
Courant Number mean: 0.113098 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 5.02451e-05, Final residual = 5.49716e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000107869, Final residual = 8.28634e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000287657, Final residual = 2.77167e-05, No Iterations 7
time step continuity errors : sum local = 5.37308e-09, global = -3.1727e-10, cumulative = 6.42174e-06
GAMG: Solving for p, Initial residual = 0.000241949, Final residual = 5.62245e-07, No Iterations 17
time step continuity errors : sum local = 1.09067e-10, global = 4.37147e-12, cumulative = 6.42175e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000312441, Final residual = 9.02921e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409923, Final residual = 9.62812e-06, No Iterations 5
ExecutionTime = 43.6 s ClockTime = 44 s
Time = 4.11
Courant Number mean: 0.1131 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.99433e-05, Final residual = 5.45272e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000107218, Final residual = 8.21907e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00029669, Final residual = 2.7692e-05, No Iterations 7
time step continuity errors : sum local = 5.36836e-09, global = -3.16476e-10, cumulative = 6.42143e-06
GAMG: Solving for p, Initial residual = 0.000240941, Final residual = 5.63533e-07, No Iterations 17
time step continuity errors : sum local = 1.09317e-10, global = 4.36845e-12, cumulative = 6.42144e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000311982, Final residual = 9.04904e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409867, Final residual = 9.68098e-06, No Iterations 5
ExecutionTime = 43.63 s ClockTime = 44 s
Time = 4.1125
Courant Number mean: 0.113101 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.96434e-05, Final residual = 5.40851e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000106578, Final residual = 8.15242e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000292081, Final residual = 2.79087e-05, No Iterations 7
time step continuity errors : sum local = 5.41037e-09, global = -3.15159e-10, cumulative = 6.42112e-06
GAMG: Solving for p, Initial residual = 0.000239749, Final residual = 5.6271e-07, No Iterations 17
time step continuity errors : sum local = 1.09159e-10, global = 4.34404e-12, cumulative = 6.42112e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000311513, Final residual = 9.06816e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409792, Final residual = 9.73265e-06, No Iterations 5
ExecutionTime = 43.66 s ClockTime = 44 s
Time = 4.115
Courant Number mean: 0.113103 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.93463e-05, Final residual = 5.36461e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000105932, Final residual = 8.08593e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000290529, Final residual = 2.79507e-05, No Iterations 7
time step continuity errors : sum local = 5.41858e-09, global = -3.13717e-10, cumulative = 6.42081e-06
GAMG: Solving for p, Initial residual = 0.000238688, Final residual = 5.63501e-07, No Iterations 17
time step continuity errors : sum local = 1.09313e-10, global = 4.33997e-12, cumulative = 6.42082e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000311036, Final residual = 9.08624e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409699, Final residual = 9.78314e-06, No Iterations 5
ExecutionTime = 43.68 s ClockTime = 44 s
Time = 4.1175
Courant Number mean: 0.113105 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.90512e-05, Final residual = 5.32103e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000105293, Final residual = 8.01998e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000288579, Final residual = 2.80397e-05, No Iterations 7
time step continuity errors : sum local = 5.43588e-09, global = -3.12706e-10, cumulative = 6.4205e-06
GAMG: Solving for p, Initial residual = 0.0002376, Final residual = 5.64075e-07, No Iterations 17
time step continuity errors : sum local = 1.09426e-10, global = 4.33627e-12, cumulative = 6.42051e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000310551, Final residual = 9.10414e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409588, Final residual = 9.83185e-06, No Iterations 5
ExecutionTime = 43.71 s ClockTime = 44 s
Time = 4.12
Courant Number mean: 0.113107 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.87592e-05, Final residual = 5.27775e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000104661, Final residual = 7.95451e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000291539, Final residual = 2.8114e-05, No Iterations 7
time step continuity errors : sum local = 5.45034e-09, global = -3.11941e-10, cumulative = 6.42019e-06
GAMG: Solving for p, Initial residual = 0.000236516, Final residual = 5.64919e-07, No Iterations 17
time step continuity errors : sum local = 1.09592e-10, global = 4.33734e-12, cumulative = 6.4202e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000310057, Final residual = 9.12043e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409462, Final residual = 9.87999e-06, No Iterations 5
ExecutionTime = 43.74 s ClockTime = 44 s
Time = 4.1225
Courant Number mean: 0.113108 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.84702e-05, Final residual = 5.23485e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000104035, Final residual = 7.88968e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000289546, Final residual = 2.81399e-05, No Iterations 7
time step continuity errors : sum local = 5.45545e-09, global = -3.10343e-10, cumulative = 6.41989e-06
GAMG: Solving for p, Initial residual = 0.000235471, Final residual = 5.65832e-07, No Iterations 17
time step continuity errors : sum local = 1.09771e-10, global = 4.34047e-12, cumulative = 6.41989e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000309554, Final residual = 9.1362e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409318, Final residual = 9.92698e-06, No Iterations 5
ExecutionTime = 43.77 s ClockTime = 44 s
Time = 4.125
Courant Number mean: 0.11311 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.81828e-05, Final residual = 5.19214e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000103408, Final residual = 7.82477e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000290033, Final residual = 2.82044e-05, No Iterations 7
time step continuity errors : sum local = 5.46806e-09, global = -3.09652e-10, cumulative = 6.41958e-06
GAMG: Solving for p, Initial residual = 0.000234532, Final residual = 5.66975e-07, No Iterations 17
time step continuity errors : sum local = 1.09994e-10, global = 4.34716e-12, cumulative = 6.41959e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000309044, Final residual = 9.15098e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000409158, Final residual = 9.97281e-06, No Iterations 5
ExecutionTime = 43.79 s ClockTime = 44 s
Time = 4.1275
Courant Number mean: 0.113112 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.78977e-05, Final residual = 5.14974e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.00010279, Final residual = 7.76055e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000282051, Final residual = 1.40179e-05, No Iterations 9
time step continuity errors : sum local = 2.71773e-09, global = -1.22043e-10, cumulative = 6.41947e-06
GAMG: Solving for p, Initial residual = 0.000235644, Final residual = 6.30985e-07, No Iterations 17
time step continuity errors : sum local = 1.22425e-10, global = 4.91418e-12, cumulative = 6.41947e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000308526, Final residual = 9.16523e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408981, Final residual = 5.73653e-06, No Iterations 6
ExecutionTime = 43.82 s ClockTime = 44 s
Time = 4.13
Courant Number mean: 0.113114 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.7603e-05, Final residual = 5.10213e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000102274, Final residual = 7.69467e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000295444, Final residual = 1.52194e-05, No Iterations 9
time step continuity errors : sum local = 2.95062e-09, global = -1.33118e-10, cumulative = 6.41934e-06
GAMG: Solving for p, Initial residual = 0.000245045, Final residual = 6.62151e-07, No Iterations 17
time step continuity errors : sum local = 1.28478e-10, global = 5.14984e-12, cumulative = 6.41934e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000308049, Final residual = 9.18264e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00040883, Final residual = 5.76738e-06, No Iterations 6
ExecutionTime = 43.85 s ClockTime = 44 s
Time = 4.1325
Courant Number mean: 0.113116 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.73176e-05, Final residual = 5.05925e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000101672, Final residual = 7.6342e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000294541, Final residual = 1.51545e-05, No Iterations 9
time step continuity errors : sum local = 2.9381e-09, global = -1.32001e-10, cumulative = 6.41921e-06
GAMG: Solving for p, Initial residual = 0.00024438, Final residual = 6.64142e-07, No Iterations 17
time step continuity errors : sum local = 1.28866e-10, global = 5.16151e-12, cumulative = 6.41922e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000307563, Final residual = 9.19875e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00040866, Final residual = 5.79736e-06, No Iterations 6
ExecutionTime = 43.87 s ClockTime = 44 s
Time = 4.135
Courant Number mean: 0.113117 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.70329e-05, Final residual = 5.01628e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000101057, Final residual = 7.56874e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000292835, Final residual = 1.52249e-05, No Iterations 9
time step continuity errors : sum local = 2.95178e-09, global = -1.31843e-10, cumulative = 6.41908e-06
GAMG: Solving for p, Initial residual = 0.000243329, Final residual = 6.67402e-07, No Iterations 17
time step continuity errors : sum local = 1.29501e-10, global = 5.19688e-12, cumulative = 6.41909e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00030707, Final residual = 9.2135e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408469, Final residual = 5.82651e-06, No Iterations 6
ExecutionTime = 43.9 s ClockTime = 44 s
Time = 4.1375
Courant Number mean: 0.113119 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.67491e-05, Final residual = 4.97396e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 0.000100453, Final residual = 7.50574e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000291674, Final residual = 1.52215e-05, No Iterations 9
time step continuity errors : sum local = 2.95118e-09, global = -1.31355e-10, cumulative = 6.41896e-06
GAMG: Solving for p, Initial residual = 0.000242018, Final residual = 6.69223e-07, No Iterations 17
time step continuity errors : sum local = 1.29857e-10, global = 5.21988e-12, cumulative = 6.41896e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00030657, Final residual = 9.22707e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00040826, Final residual = 5.8544e-06, No Iterations 6
ExecutionTime = 43.92 s ClockTime = 44 s
Time = 4.14
Courant Number mean: 0.113121 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.64689e-05, Final residual = 4.93193e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.98512e-05, Final residual = 7.44229e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000292102, Final residual = 1.52429e-05, No Iterations 9
time step continuity errors : sum local = 2.95539e-09, global = -1.30926e-10, cumulative = 6.41883e-06
GAMG: Solving for p, Initial residual = 0.000240796, Final residual = 6.7153e-07, No Iterations 17
time step continuity errors : sum local = 1.30308e-10, global = 5.2492e-12, cumulative = 6.41884e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000306063, Final residual = 9.24036e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000408033, Final residual = 5.88182e-06, No Iterations 6
ExecutionTime = 43.95 s ClockTime = 44 s
Time = 4.1425
Courant Number mean: 0.113123 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 4.61917e-05, Final residual = 4.89017e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.92531e-05, Final residual = 7.37958e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000297615, Final residual = 1.52511e-05, No Iterations 9
time step continuity errors : sum local = 2.95707e-09, global = -1.30457e-10, cumulative = 6.41871e-06
GAMG: Solving for p, Initial residual = 0.000239677, Final residual = 6.73679e-07, No Iterations 17
time step continuity errors : sum local = 1.30729e-10, global = 5.27719e-12, cumulative = 6.41871e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000305548, Final residual = 9.25276e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000407787, Final residual = 5.90794e-06, No Iterations 6
ExecutionTime = 43.97 s ClockTime = 44 s
Time = 4.145
Courant Number mean: 0.113125 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.59178e-05, Final residual = 4.84892e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.86588e-05, Final residual = 7.3175e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000299417, Final residual = 1.52683e-05, No Iterations 9
time step continuity errors : sum local = 2.96049e-09, global = -1.3005e-10, cumulative = 6.41858e-06
GAMG: Solving for p, Initial residual = 0.000238499, Final residual = 6.75785e-07, No Iterations 17
time step continuity errors : sum local = 1.31142e-10, global = 5.30542e-12, cumulative = 6.41859e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000305026, Final residual = 9.26428e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000407523, Final residual = 5.93368e-06, No Iterations 6
ExecutionTime = 44 s ClockTime = 44 s
Time = 4.1475
Courant Number mean: 0.113127 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.56462e-05, Final residual = 4.808e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.80666e-05, Final residual = 7.25621e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000298211, Final residual = 1.52914e-05, No Iterations 9
time step continuity errors : sum local = 2.96507e-09, global = -1.29684e-10, cumulative = 6.41846e-06
GAMG: Solving for p, Initial residual = 0.000237388, Final residual = 6.77473e-07, No Iterations 17
time step continuity errors : sum local = 1.31474e-10, global = 5.32894e-12, cumulative = 6.41846e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000304497, Final residual = 9.27436e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000407241, Final residual = 5.95861e-06, No Iterations 6
ExecutionTime = 44.02 s ClockTime = 44 s
Time = 4.15
Courant Number mean: 0.113128 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.53767e-05, Final residual = 4.76743e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.74751e-05, Final residual = 7.19536e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00028887, Final residual = 1.52793e-05, No Iterations 9
time step continuity errors : sum local = 2.96281e-09, global = -1.29303e-10, cumulative = 6.41833e-06
GAMG: Solving for p, Initial residual = 0.000235996, Final residual = 6.80594e-07, No Iterations 17
time step continuity errors : sum local = 1.32083e-10, global = 5.37149e-12, cumulative = 6.41834e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00030396, Final residual = 9.2849e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000406943, Final residual = 5.98274e-06, No Iterations 6
ExecutionTime = 44.05 s ClockTime = 44 s
Time = 4.1525
Courant Number mean: 0.11313 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.51093e-05, Final residual = 4.72693e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.68934e-05, Final residual = 7.13525e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000297878, Final residual = 1.52785e-05, No Iterations 9
time step continuity errors : sum local = 2.96272e-09, global = -1.28747e-10, cumulative = 6.41821e-06
GAMG: Solving for p, Initial residual = 0.000235524, Final residual = 6.83279e-07, No Iterations 17
time step continuity errors : sum local = 1.32607e-10, global = 5.40966e-12, cumulative = 6.41822e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000303416, Final residual = 9.29385e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000406626, Final residual = 6.00624e-06, No Iterations 6
ExecutionTime = 44.07 s ClockTime = 44 s
Time = 4.155
Courant Number mean: 0.113132 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.48425e-05, Final residual = 4.68682e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.63173e-05, Final residual = 7.07522e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00029562, Final residual = 1.52655e-05, No Iterations 9
time step continuity errors : sum local = 2.96021e-09, global = -1.28304e-10, cumulative = 6.41809e-06
GAMG: Solving for p, Initial residual = 0.000234625, Final residual = 6.86136e-07, No Iterations 17
time step continuity errors : sum local = 1.33162e-10, global = 5.45017e-12, cumulative = 6.41809e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000302865, Final residual = 9.30206e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000406292, Final residual = 6.02878e-06, No Iterations 6
ExecutionTime = 44.1 s ClockTime = 44 s
Time = 4.1575
Courant Number mean: 0.113134 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.45769e-05, Final residual = 4.64697e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.57472e-05, Final residual = 7.01582e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00028714, Final residual = 1.52918e-05, No Iterations 9
time step continuity errors : sum local = 2.96534e-09, global = -1.27764e-10, cumulative = 6.41797e-06
GAMG: Solving for p, Initial residual = 0.000233023, Final residual = 6.8692e-07, No Iterations 17
time step continuity errors : sum local = 1.33317e-10, global = 5.46372e-12, cumulative = 6.41797e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000302306, Final residual = 9.30902e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000405941, Final residual = 6.05054e-06, No Iterations 6
ExecutionTime = 44.12 s ClockTime = 44 s
Time = 4.16
Courant Number mean: 0.113136 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.43132e-05, Final residual = 4.60754e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.51761e-05, Final residual = 6.95644e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000284338, Final residual = 1.5291e-05, No Iterations 9
time step continuity errors : sum local = 2.96526e-09, global = -1.2744e-10, cumulative = 6.41784e-06
GAMG: Solving for p, Initial residual = 0.000231677, Final residual = 6.88513e-07, No Iterations 17
time step continuity errors : sum local = 1.33629e-10, global = 5.48756e-12, cumulative = 6.41785e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000301739, Final residual = 9.31552e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000405574, Final residual = 6.0715e-06, No Iterations 6
ExecutionTime = 44.15 s ClockTime = 44 s
Time = 4.1625
Courant Number mean: 0.113138 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.40507e-05, Final residual = 4.56881e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.46117e-05, Final residual = 6.89798e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000283399, Final residual = 1.52929e-05, No Iterations 9
time step continuity errors : sum local = 2.96571e-09, global = -1.26997e-10, cumulative = 6.41772e-06
GAMG: Solving for p, Initial residual = 0.000230453, Final residual = 6.90481e-07, No Iterations 17
time step continuity errors : sum local = 1.34014e-10, global = 5.51747e-12, cumulative = 6.41773e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000301163, Final residual = 9.32127e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000405189, Final residual = 6.09171e-06, No Iterations 6
ExecutionTime = 44.17 s ClockTime = 44 s
Time = 4.165
Courant Number mean: 0.11314 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.37922e-05, Final residual = 4.53054e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.40522e-05, Final residual = 6.8399e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000282197, Final residual = 1.52906e-05, No Iterations 9
time step continuity errors : sum local = 2.96532e-09, global = -1.26568e-10, cumulative = 6.4176e-06
GAMG: Solving for p, Initial residual = 0.000229263, Final residual = 6.92462e-07, No Iterations 17
time step continuity errors : sum local = 1.34402e-10, global = 5.54755e-12, cumulative = 6.41761e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00030058, Final residual = 9.32622e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000404789, Final residual = 6.11115e-06, No Iterations 6
ExecutionTime = 44.2 s ClockTime = 44 s
Time = 4.1675
Courant Number mean: 0.113142 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.35364e-05, Final residual = 4.4927e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.34968e-05, Final residual = 6.78228e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000280571, Final residual = 1.52872e-05, No Iterations 9
time step continuity errors : sum local = 2.96474e-09, global = -1.26131e-10, cumulative = 6.41748e-06
GAMG: Solving for p, Initial residual = 0.000228077, Final residual = 6.94276e-07, No Iterations 17
time step continuity errors : sum local = 1.34757e-10, global = 5.57691e-12, cumulative = 6.41749e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000299989, Final residual = 9.33059e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000404372, Final residual = 6.12991e-06, No Iterations 6
ExecutionTime = 44.22 s ClockTime = 45 s
Time = 4.17
Courant Number mean: 0.113144 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.32837e-05, Final residual = 4.45514e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.29474e-05, Final residual = 6.72519e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.0002795, Final residual = 1.52782e-05, No Iterations 9
time step continuity errors : sum local = 2.96307e-09, global = -1.25665e-10, cumulative = 6.41736e-06
GAMG: Solving for p, Initial residual = 0.000226889, Final residual = 6.96004e-07, No Iterations 17
time step continuity errors : sum local = 1.35096e-10, global = 5.60552e-12, cumulative = 6.41737e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000299392, Final residual = 9.33453e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000403939, Final residual = 6.14788e-06, No Iterations 6
ExecutionTime = 44.25 s ClockTime = 45 s
Time = 4.1725
Courant Number mean: 0.113145 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.30328e-05, Final residual = 4.41795e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.24013e-05, Final residual = 6.66833e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000278299, Final residual = 1.52701e-05, No Iterations 9
time step continuity errors : sum local = 2.96156e-09, global = -1.25208e-10, cumulative = 6.41724e-06
GAMG: Solving for p, Initial residual = 0.000225714, Final residual = 6.97719e-07, No Iterations 17
time step continuity errors : sum local = 1.35432e-10, global = 5.63405e-12, cumulative = 6.41725e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000298788, Final residual = 9.33707e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00040349, Final residual = 6.1651e-06, No Iterations 6
ExecutionTime = 44.27 s ClockTime = 45 s
Time = 4.175
Courant Number mean: 0.113147 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.27849e-05, Final residual = 4.38111e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.18583e-05, Final residual = 6.61178e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000277114, Final residual = 1.52595e-05, No Iterations 9
time step continuity errors : sum local = 2.95959e-09, global = -1.2475e-10, cumulative = 6.41712e-06
GAMG: Solving for p, Initial residual = 0.000224532, Final residual = 6.99369e-07, No Iterations 17
time step continuity errors : sum local = 1.35756e-10, global = 5.6621e-12, cumulative = 6.41713e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000298176, Final residual = 9.33905e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000403026, Final residual = 6.18117e-06, No Iterations 6
ExecutionTime = 44.3 s ClockTime = 45 s
Time = 4.1775
Courant Number mean: 0.113149 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.25383e-05, Final residual = 4.34457e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.13182e-05, Final residual = 6.55569e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000276015, Final residual = 1.52478e-05, No Iterations 9
time step continuity errors : sum local = 2.95739e-09, global = -1.24291e-10, cumulative = 6.417e-06
GAMG: Solving for p, Initial residual = 0.000223363, Final residual = 7.00939e-07, No Iterations 17
time step continuity errors : sum local = 1.36064e-10, global = 5.68943e-12, cumulative = 6.41701e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000297558, Final residual = 9.33999e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000402546, Final residual = 6.19696e-06, No Iterations 6
ExecutionTime = 44.32 s ClockTime = 45 s
Time = 4.18
Courant Number mean: 0.113151 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.22936e-05, Final residual = 4.30858e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.07813e-05, Final residual = 6.49984e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000274976, Final residual = 1.52347e-05, No Iterations 9
time step continuity errors : sum local = 2.95493e-09, global = -1.23831e-10, cumulative = 6.41688e-06
GAMG: Solving for p, Initial residual = 0.000222194, Final residual = 7.02437e-07, No Iterations 17
time step continuity errors : sum local = 1.36359e-10, global = 5.71615e-12, cumulative = 6.41689e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000296944, Final residual = 9.34081e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000402051, Final residual = 6.21206e-06, No Iterations 6
ExecutionTime = 44.35 s ClockTime = 45 s
Time = 4.1825
Courant Number mean: 0.113153 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.20516e-05, Final residual = 4.2729e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 9.02489e-05, Final residual = 6.44433e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00027388, Final residual = 1.52206e-05, No Iterations 9
time step continuity errors : sum local = 2.95228e-09, global = -1.23374e-10, cumulative = 6.41677e-06
GAMG: Solving for p, Initial residual = 0.000221029, Final residual = 7.03875e-07, No Iterations 17
time step continuity errors : sum local = 1.36641e-10, global = 5.74226e-12, cumulative = 6.41677e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000296312, Final residual = 9.34014e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000401541, Final residual = 6.22655e-06, No Iterations 6
ExecutionTime = 44.37 s ClockTime = 45 s
Time = 4.185
Courant Number mean: 0.113155 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.18121e-05, Final residual = 4.2377e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 8.97195e-05, Final residual = 6.38939e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000272509, Final residual = 1.52064e-05, No Iterations 9
time step continuity errors : sum local = 2.9496e-09, global = -1.22923e-10, cumulative = 6.41665e-06
GAMG: Solving for p, Initial residual = 0.000219878, Final residual = 7.05247e-07, No Iterations 17
time step continuity errors : sum local = 1.36911e-10, global = 5.76775e-12, cumulative = 6.41666e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000295673, Final residual = 9.33842e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000401017, Final residual = 6.24064e-06, No Iterations 6
ExecutionTime = 44.4 s ClockTime = 45 s
Time = 4.1875
Courant Number mean: 0.113157 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.15747e-05, Final residual = 4.20292e-06, No Iterations 2
smoothSolver: Solving for Uy, Initial residual = 8.91913e-05, Final residual = 6.33484e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000271479, Final residual = 1.51895e-05, No Iterations 9
time step continuity errors : sum local = 2.94641e-09, global = -1.22462e-10, cumulative = 6.41653e-06
GAMG: Solving for p, Initial residual = 0.000218729, Final residual = 7.06547e-07, No Iterations 17
time step continuity errors : sum local = 1.37168e-10, global = 5.79254e-12, cumulative = 6.41654e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000295027, Final residual = 9.33718e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000400478, Final residual = 6.25401e-06, No Iterations 6
ExecutionTime = 44.43 s ClockTime = 45 s
Time = 4.19
Courant Number mean: 0.113159 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.134e-05, Final residual = 9.93361e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.86671e-05, Final residual = 6.28062e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000475873, Final residual = 3.37416e-05, No Iterations 9
time step continuity errors : sum local = 6.54537e-09, global = -2.48148e-10, cumulative = 6.41629e-06
GAMG: Solving for p, Initial residual = 0.000471885, Final residual = 8.1621e-07, No Iterations 19
time step continuity errors : sum local = 1.5869e-10, global = 7.32779e-12, cumulative = 6.4163e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000294365, Final residual = 9.3306e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000399902, Final residual = 6.26406e-06, No Iterations 6
ExecutionTime = 44.45 s ClockTime = 45 s
Time = 4.1925
Courant Number mean: 0.11316 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.12378e-05, Final residual = 9.99425e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.84158e-05, Final residual = 6.31317e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000522753, Final residual = 3.01166e-05, No Iterations 9
time step continuity errors : sum local = 5.84496e-09, global = -2.34208e-10, cumulative = 6.41606e-06
GAMG: Solving for p, Initial residual = 0.000458364, Final residual = 8.07018e-07, No Iterations 19
time step continuity errors : sum local = 1.56882e-10, global = 7.29536e-12, cumulative = 6.41607e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000293696, Final residual = 9.3253e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000399315, Final residual = 6.27364e-06, No Iterations 6
ExecutionTime = 44.48 s ClockTime = 45 s
Time = 4.195
Courant Number mean: 0.113162 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.10102e-05, Final residual = 9.91808e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.78892e-05, Final residual = 6.25119e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000508008, Final residual = 3.09654e-05, No Iterations 9
time step continuity errors : sum local = 6.00928e-09, global = -2.35723e-10, cumulative = 6.41584e-06
GAMG: Solving for p, Initial residual = 0.000455652, Final residual = 8.04313e-07, No Iterations 19
time step continuity errors : sum local = 1.56368e-10, global = 7.29061e-12, cumulative = 6.41584e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000293022, Final residual = 9.31915e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000398714, Final residual = 6.28267e-06, No Iterations 6
ExecutionTime = 44.51 s ClockTime = 45 s
Time = 4.1975
Courant Number mean: 0.113164 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.08107e-05, Final residual = 9.86897e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.74118e-05, Final residual = 6.20916e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000494589, Final residual = 3.06964e-05, No Iterations 9
time step continuity errors : sum local = 5.95742e-09, global = -2.31843e-10, cumulative = 6.41561e-06
GAMG: Solving for p, Initial residual = 0.000451826, Final residual = 8.03774e-07, No Iterations 19
time step continuity errors : sum local = 1.56265e-10, global = 7.29347e-12, cumulative = 6.41562e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000292343, Final residual = 9.31189e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000398101, Final residual = 6.29158e-06, No Iterations 6
ExecutionTime = 44.54 s ClockTime = 45 s
Time = 4.2
Courant Number mean: 0.113166 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.06079e-05, Final residual = 9.81359e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.69006e-05, Final residual = 6.15612e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000485044, Final residual = 3.07034e-05, No Iterations 9
time step continuity errors : sum local = 5.95889e-09, global = -2.3065e-10, cumulative = 6.41539e-06
GAMG: Solving for p, Initial residual = 0.000449463, Final residual = 8.01792e-07, No Iterations 19
time step continuity errors : sum local = 1.55885e-10, global = 7.28742e-12, cumulative = 6.41539e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000291658, Final residual = 9.30429e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000397475, Final residual = 6.29957e-06, No Iterations 6
ExecutionTime = 44.6 s ClockTime = 45 s
Time = 4.2025
Courant Number mean: 0.113168 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.04065e-05, Final residual = 9.75913e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.64242e-05, Final residual = 6.11043e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000482546, Final residual = 3.06469e-05, No Iterations 9
time step continuity errors : sum local = 5.94811e-09, global = -2.30254e-10, cumulative = 6.41516e-06
GAMG: Solving for p, Initial residual = 0.000447467, Final residual = 8.01471e-07, No Iterations 19
time step continuity errors : sum local = 1.55827e-10, global = 7.2944e-12, cumulative = 6.41517e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000290966, Final residual = 9.29614e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000396836, Final residual = 6.30767e-06, No Iterations 6
ExecutionTime = 44.63 s ClockTime = 45 s
Time = 4.205
Courant Number mean: 0.113169 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.02062e-05, Final residual = 9.70438e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.59452e-05, Final residual = 6.06233e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000478735, Final residual = 3.06202e-05, No Iterations 9
time step continuity errors : sum local = 5.9431e-09, global = -2.29635e-10, cumulative = 6.41494e-06
GAMG: Solving for p, Initial residual = 0.000445649, Final residual = 8.00548e-07, No Iterations 19
time step continuity errors : sum local = 1.55652e-10, global = 7.29746e-12, cumulative = 6.41495e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000290269, Final residual = 9.28722e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000396184, Final residual = 6.31501e-06, No Iterations 6
ExecutionTime = 44.66 s ClockTime = 45 s
Time = 4.2075
Courant Number mean: 0.113171 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 4.00069e-05, Final residual = 9.65063e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.54775e-05, Final residual = 6.01616e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000478579, Final residual = 3.0589e-05, No Iterations 9
time step continuity errors : sum local = 5.93722e-09, global = -2.29203e-10, cumulative = 6.41472e-06
GAMG: Solving for p, Initial residual = 0.000443863, Final residual = 7.99948e-07, No Iterations 19
time step continuity errors : sum local = 1.55538e-10, global = 7.30279e-12, cumulative = 6.41473e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000289563, Final residual = 9.277e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000395521, Final residual = 6.32147e-06, No Iterations 6
ExecutionTime = 44.69 s ClockTime = 45 s
Time = 4.21
Courant Number mean: 0.113173 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.98098e-05, Final residual = 9.59767e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.50116e-05, Final residual = 5.96946e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000476013, Final residual = 3.05529e-05, No Iterations 9
time step continuity errors : sum local = 5.93035e-09, global = -2.28697e-10, cumulative = 6.4145e-06
GAMG: Solving for p, Initial residual = 0.00044212, Final residual = 7.99099e-07, No Iterations 19
time step continuity errors : sum local = 1.55377e-10, global = 7.30556e-12, cumulative = 6.41451e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000288852, Final residual = 9.26731e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000394845, Final residual = 6.32717e-06, No Iterations 6
ExecutionTime = 44.72 s ClockTime = 45 s
Time = 4.2125
Courant Number mean: 0.113175 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.96146e-05, Final residual = 9.5452e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.45516e-05, Final residual = 5.92335e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000473801, Final residual = 3.05219e-05, No Iterations 9
time step continuity errors : sum local = 5.92448e-09, global = -2.28237e-10, cumulative = 6.41428e-06
GAMG: Solving for p, Initial residual = 0.000440361, Final residual = 7.98298e-07, No Iterations 19
time step continuity errors : sum local = 1.55225e-10, global = 7.30905e-12, cumulative = 6.41429e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000288134, Final residual = 9.25698e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000394157, Final residual = 6.33247e-06, No Iterations 6
ExecutionTime = 44.74 s ClockTime = 45 s
Time = 4.215
Courant Number mean: 0.113176 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.94213e-05, Final residual = 9.49317e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.40952e-05, Final residual = 5.87731e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000471957, Final residual = 3.04875e-05, No Iterations 9
time step continuity errors : sum local = 5.91796e-09, global = -2.27754e-10, cumulative = 6.41406e-06
GAMG: Solving for p, Initial residual = 0.000438593, Final residual = 7.97388e-07, No Iterations 19
time step continuity errors : sum local = 1.55051e-10, global = 7.31172e-12, cumulative = 6.41406e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00028741, Final residual = 9.24659e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000393458, Final residual = 6.33735e-06, No Iterations 6
ExecutionTime = 44.77 s ClockTime = 45 s
Time = 4.2175
Courant Number mean: 0.113178 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.92295e-05, Final residual = 9.44142e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.3642e-05, Final residual = 5.8317e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000470115, Final residual = 3.05643e-05, No Iterations 9
time step continuity errors : sum local = 5.93302e-09, global = -2.24874e-10, cumulative = 6.41384e-06
GAMG: Solving for p, Initial residual = 0.000436927, Final residual = 7.96081e-07, No Iterations 19
time step continuity errors : sum local = 1.54801e-10, global = 7.30825e-12, cumulative = 6.41385e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00028668, Final residual = 9.23456e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000392747, Final residual = 6.342e-06, No Iterations 6
ExecutionTime = 44.8 s ClockTime = 45 s
Time = 4.22
Courant Number mean: 0.11318 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.9038e-05, Final residual = 9.3897e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.31904e-05, Final residual = 5.78618e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000468321, Final residual = 3.05245e-05, No Iterations 9
time step continuity errors : sum local = 5.92545e-09, global = -2.24337e-10, cumulative = 6.41362e-06
GAMG: Solving for p, Initial residual = 0.000435126, Final residual = 7.94988e-07, No Iterations 19
time step continuity errors : sum local = 1.54593e-10, global = 7.3094e-12, cumulative = 6.41363e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000285944, Final residual = 9.22287e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000392027, Final residual = 6.34545e-06, No Iterations 6
ExecutionTime = 44.83 s ClockTime = 45 s
Time = 4.2225
Courant Number mean: 0.113182 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.8849e-05, Final residual = 9.33847e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.27426e-05, Final residual = 5.7408e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000466313, Final residual = 3.04835e-05, No Iterations 9
time step continuity errors : sum local = 5.91766e-09, global = -2.23843e-10, cumulative = 6.41341e-06
GAMG: Solving for p, Initial residual = 0.000433314, Final residual = 7.9387e-07, No Iterations 19
time step continuity errors : sum local = 1.54379e-10, global = 7.31007e-12, cumulative = 6.41341e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000285201, Final residual = 9.21051e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000391295, Final residual = 6.34905e-06, No Iterations 6
ExecutionTime = 44.85 s ClockTime = 45 s
Time = 4.225
Courant Number mean: 0.113183 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.86612e-05, Final residual = 9.2874e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.22978e-05, Final residual = 5.69574e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000466144, Final residual = 3.04417e-05, No Iterations 9
time step continuity errors : sum local = 5.90969e-09, global = -2.23362e-10, cumulative = 6.41319e-06
GAMG: Solving for p, Initial residual = 0.000431501, Final residual = 7.92688e-07, No Iterations 19
time step continuity errors : sum local = 1.54153e-10, global = 7.31008e-12, cumulative = 6.4132e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000284455, Final residual = 9.19715e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000390552, Final residual = 6.35169e-06, No Iterations 6
ExecutionTime = 44.89 s ClockTime = 45 s
Time = 4.2275
Courant Number mean: 0.113185 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.84743e-05, Final residual = 9.23672e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.18547e-05, Final residual = 5.65103e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00046821, Final residual = 3.03964e-05, No Iterations 9
time step continuity errors : sum local = 5.90106e-09, global = -2.22877e-10, cumulative = 6.41297e-06
GAMG: Solving for p, Initial residual = 0.000429671, Final residual = 7.91446e-07, No Iterations 19
time step continuity errors : sum local = 1.53915e-10, global = 7.30949e-12, cumulative = 6.41298e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000283703, Final residual = 9.1838e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000389798, Final residual = 6.35404e-06, No Iterations 6
ExecutionTime = 44.92 s ClockTime = 45 s
Time = 4.23
Courant Number mean: 0.113187 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.82887e-05, Final residual = 9.18672e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.14155e-05, Final residual = 5.60659e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000468027, Final residual = 3.03468e-05, No Iterations 9
time step continuity errors : sum local = 5.89159e-09, global = -2.22367e-10, cumulative = 6.41276e-06
GAMG: Solving for p, Initial residual = 0.000427834, Final residual = 7.90183e-07, No Iterations 19
time step continuity errors : sum local = 1.53673e-10, global = 7.30823e-12, cumulative = 6.41277e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000282946, Final residual = 9.17003e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000389033, Final residual = 6.35554e-06, No Iterations 6
ExecutionTime = 44.94 s ClockTime = 45 s
Time = 4.2325
Courant Number mean: 0.113189 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.81043e-05, Final residual = 9.13738e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.09789e-05, Final residual = 5.5625e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000468504, Final residual = 3.02956e-05, No Iterations 9
time step continuity errors : sum local = 5.88182e-09, global = -2.2184e-10, cumulative = 6.41255e-06
GAMG: Solving for p, Initial residual = 0.000426059, Final residual = 7.88939e-07, No Iterations 19
time step continuity errors : sum local = 1.53435e-10, global = 7.30627e-12, cumulative = 6.41255e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000282184, Final residual = 9.15586e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000388256, Final residual = 6.35669e-06, No Iterations 6
ExecutionTime = 44.97 s ClockTime = 45 s
Time = 4.235
Courant Number mean: 0.113191 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.79227e-05, Final residual = 9.08852e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.05452e-05, Final residual = 5.51858e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000473041, Final residual = 3.0243e-05, No Iterations 9
time step continuity errors : sum local = 5.8718e-09, global = -2.21297e-10, cumulative = 6.41233e-06
GAMG: Solving for p, Initial residual = 0.000424574, Final residual = 7.87647e-07, No Iterations 19
time step continuity errors : sum local = 1.53188e-10, global = 7.30371e-12, cumulative = 6.41234e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000281418, Final residual = 9.14179e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000387469, Final residual = 6.35775e-06, No Iterations 6
ExecutionTime = 45 s ClockTime = 45 s
Time = 4.2375
Courant Number mean: 0.113192 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.7742e-05, Final residual = 9.04052e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 8.01202e-05, Final residual = 5.47492e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000471491, Final residual = 3.01876e-05, No Iterations 9
time step continuity errors : sum local = 5.86124e-09, global = -2.2076e-10, cumulative = 6.41212e-06
GAMG: Solving for p, Initial residual = 0.000422706, Final residual = 7.86288e-07, No Iterations 19
time step continuity errors : sum local = 1.52929e-10, global = 7.30053e-12, cumulative = 6.41212e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000280646, Final residual = 9.12674e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000386672, Final residual = 6.35777e-06, No Iterations 6
ExecutionTime = 45.03 s ClockTime = 45 s
Time = 4.24
Courant Number mean: 0.113194 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.75634e-05, Final residual = 8.99278e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.96966e-05, Final residual = 5.43168e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000478607, Final residual = 3.01302e-05, No Iterations 9
time step continuity errors : sum local = 5.85033e-09, global = -2.20205e-10, cumulative = 6.4119e-06
GAMG: Solving for p, Initial residual = 0.000421216, Final residual = 7.84891e-07, No Iterations 19
time step continuity errors : sum local = 1.52662e-10, global = 7.29709e-12, cumulative = 6.41191e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000279869, Final residual = 9.11147e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000385865, Final residual = 6.35757e-06, No Iterations 6
ExecutionTime = 45.06 s ClockTime = 45 s
Time = 4.2425
Courant Number mean: 0.113196 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.73858e-05, Final residual = 8.94542e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.92755e-05, Final residual = 5.38852e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.00047093, Final residual = 3.00694e-05, No Iterations 9
time step continuity errors : sum local = 5.83872e-09, global = -2.19669e-10, cumulative = 6.41169e-06
GAMG: Solving for p, Initial residual = 0.000419029, Final residual = 7.83429e-07, No Iterations 19
time step continuity errors : sum local = 1.52381e-10, global = 7.29284e-12, cumulative = 6.4117e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000279087, Final residual = 9.09452e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000385047, Final residual = 6.35765e-06, No Iterations 6
ExecutionTime = 45.08 s ClockTime = 45 s
Time = 4.245
Courant Number mean: 0.113198 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.72096e-05, Final residual = 8.89829e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.88568e-05, Final residual = 5.34541e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000463518, Final residual = 3.00073e-05, No Iterations 9
time step continuity errors : sum local = 5.82683e-09, global = -2.19111e-10, cumulative = 6.41148e-06
GAMG: Solving for p, Initial residual = 0.00041679, Final residual = 7.81897e-07, No Iterations 19
time step continuity errors : sum local = 1.52088e-10, global = 7.28741e-12, cumulative = 6.41149e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000278301, Final residual = 9.07808e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00038422, Final residual = 6.3568e-06, No Iterations 6
ExecutionTime = 45.11 s ClockTime = 45 s
Time = 4.2475
Courant Number mean: 0.113199 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.70346e-05, Final residual = 8.85143e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.84394e-05, Final residual = 5.3025e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000461411, Final residual = 2.9943e-05, No Iterations 9
time step continuity errors : sum local = 5.81452e-09, global = -2.18537e-10, cumulative = 6.41127e-06
GAMG: Solving for p, Initial residual = 0.000414879, Final residual = 7.80402e-07, No Iterations 19
time step continuity errors : sum local = 1.51801e-10, global = 7.28157e-12, cumulative = 6.41128e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000277509, Final residual = 9.06079e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000383383, Final residual = 6.3552e-06, No Iterations 6
ExecutionTime = 45.14 s ClockTime = 45 s
Time = 4.25
Courant Number mean: 0.113201 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.68608e-05, Final residual = 8.80508e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.80251e-05, Final residual = 5.25989e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000459457, Final residual = 2.98767e-05, No Iterations 9
time step continuity errors : sum local = 5.80184e-09, global = -2.17958e-10, cumulative = 6.41106e-06
GAMG: Solving for p, Initial residual = 0.000412963, Final residual = 7.7894e-07, No Iterations 19
time step continuity errors : sum local = 1.51521e-10, global = 7.27519e-12, cumulative = 6.41107e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000276712, Final residual = 9.04399e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000382537, Final residual = 6.35271e-06, No Iterations 6
ExecutionTime = 45.17 s ClockTime = 45 s
Time = 4.2525
Courant Number mean: 0.113203 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.66873e-05, Final residual = 8.75923e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.76145e-05, Final residual = 5.21748e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000457693, Final residual = 2.98085e-05, No Iterations 9
time step continuity errors : sum local = 5.7888e-09, global = -2.17371e-10, cumulative = 6.41085e-06
GAMG: Solving for p, Initial residual = 0.000411048, Final residual = 7.77446e-07, No Iterations 19
time step continuity errors : sum local = 1.51235e-10, global = 7.26821e-12, cumulative = 6.41086e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000275911, Final residual = 9.02658e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000381681, Final residual = 6.35046e-06, No Iterations 6
ExecutionTime = 45.2 s ClockTime = 45 s
Time = 4.255
Courant Number mean: 0.113205 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.65142e-05, Final residual = 8.71386e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.72065e-05, Final residual = 5.17527e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000456112, Final residual = 2.97382e-05, No Iterations 9
time step continuity errors : sum local = 5.77535e-09, global = -2.16776e-10, cumulative = 6.41064e-06
GAMG: Solving for p, Initial residual = 0.000409129, Final residual = 7.75922e-07, No Iterations 19
time step continuity errors : sum local = 1.50943e-10, global = 7.26065e-12, cumulative = 6.41065e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000275104, Final residual = 9.00815e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000380816, Final residual = 6.34781e-06, No Iterations 6
ExecutionTime = 45.23 s ClockTime = 46 s
Time = 4.2575
Courant Number mean: 0.113207 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.63432e-05, Final residual = 8.66897e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.67996e-05, Final residual = 5.13327e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000454596, Final residual = 2.96661e-05, No Iterations 9
time step continuity errors : sum local = 5.76154e-09, global = -2.16175e-10, cumulative = 6.41043e-06
GAMG: Solving for p, Initial residual = 0.000407209, Final residual = 7.74432e-07, No Iterations 19
time step continuity errors : sum local = 1.50658e-10, global = 7.25255e-12, cumulative = 6.41044e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000274294, Final residual = 8.98967e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000379941, Final residual = 6.34435e-06, No Iterations 6
ExecutionTime = 45.26 s ClockTime = 46 s
Time = 4.26
Courant Number mean: 0.113208 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.61756e-05, Final residual = 8.62446e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.63934e-05, Final residual = 5.09148e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000453129, Final residual = 2.9592e-05, No Iterations 9
time step continuity errors : sum local = 5.74737e-09, global = -2.15567e-10, cumulative = 6.41022e-06
GAMG: Solving for p, Initial residual = 0.000405299, Final residual = 7.72906e-07, No Iterations 19
time step continuity errors : sum local = 1.50366e-10, global = 7.2439e-12, cumulative = 6.41023e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000273478, Final residual = 8.97104e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000379056, Final residual = 6.34035e-06, No Iterations 6
ExecutionTime = 45.29 s ClockTime = 46 s
Time = 4.2625
Courant Number mean: 0.11321 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.60094e-05, Final residual = 8.58049e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.5989e-05, Final residual = 5.05036e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000451916, Final residual = 2.95163e-05, No Iterations 9
time step continuity errors : sum local = 5.73288e-09, global = -2.14952e-10, cumulative = 6.41001e-06
GAMG: Solving for p, Initial residual = 0.000403382, Final residual = 7.71346e-07, No Iterations 19
time step continuity errors : sum local = 1.50068e-10, global = 7.23475e-12, cumulative = 6.41002e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000272659, Final residual = 8.95172e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000378163, Final residual = 6.33639e-06, No Iterations 6
ExecutionTime = 45.33 s ClockTime = 46 s
Time = 4.265
Courant Number mean: 0.113212 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.58446e-05, Final residual = 8.53714e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.55871e-05, Final residual = 5.00969e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000450525, Final residual = 2.94388e-05, No Iterations 9
time step continuity errors : sum local = 5.71806e-09, global = -2.14331e-10, cumulative = 6.40981e-06
GAMG: Solving for p, Initial residual = 0.000401464, Final residual = 7.69734e-07, No Iterations 19
time step continuity errors : sum local = 1.49759e-10, global = 7.2251e-12, cumulative = 6.40981e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000271835, Final residual = 8.93206e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000377262, Final residual = 6.33208e-06, No Iterations 6
ExecutionTime = 45.36 s ClockTime = 46 s
Time = 4.2675
Courant Number mean: 0.113214 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.56802e-05, Final residual = 8.49404e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.51872e-05, Final residual = 4.96947e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000449098, Final residual = 2.93599e-05, No Iterations 9
time step continuity errors : sum local = 5.70296e-09, global = -2.13709e-10, cumulative = 6.4096e-06
GAMG: Solving for p, Initial residual = 0.00039955, Final residual = 7.68077e-07, No Iterations 19
time step continuity errors : sum local = 1.49442e-10, global = 7.21497e-12, cumulative = 6.40961e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000271007, Final residual = 8.91221e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000376353, Final residual = 6.32714e-06, No Iterations 6
ExecutionTime = 45.4 s ClockTime = 46 s
Time = 4.27
Courant Number mean: 0.113215 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.55166e-05, Final residual = 8.45119e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.47924e-05, Final residual = 9.9509e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000411689, Final residual = 2.71965e-05, No Iterations 9
time step continuity errors : sum local = 5.28292e-09, global = -1.93458e-10, cumulative = 6.40941e-06
GAMG: Solving for p, Initial residual = 0.000343853, Final residual = 6.73972e-07, No Iterations 19
time step continuity errors : sum local = 1.31136e-10, global = 6.13394e-12, cumulative = 6.40942e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000270175, Final residual = 8.89146e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000375436, Final residual = 6.32238e-06, No Iterations 6
ExecutionTime = 45.42 s ClockTime = 46 s
Time = 4.2725
Courant Number mean: 0.113217 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.53437e-05, Final residual = 8.40984e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.49492e-05, Final residual = 5.02777e-06, No Iterations 3
GAMG: Solving for p, Initial residual = 0.000432767, Final residual = 2.9468e-05, No Iterations 9
time step continuity errors : sum local = 5.72451e-09, global = -2.17455e-10, cumulative = 6.4092e-06
GAMG: Solving for p, Initial residual = 0.000386957, Final residual = 7.79596e-07, No Iterations 19
time step continuity errors : sum local = 1.51691e-10, global = 7.43535e-12, cumulative = 6.40921e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00026934, Final residual = 8.87146e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000374511, Final residual = 6.31713e-06, No Iterations 6
ExecutionTime = 45.46 s ClockTime = 46 s
Time = 4.275
Courant Number mean: 0.113219 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.51941e-05, Final residual = 8.36371e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.38701e-05, Final residual = 9.74912e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000416591, Final residual = 2.74337e-05, No Iterations 9
time step continuity errors : sum local = 5.32936e-09, global = -1.98667e-10, cumulative = 6.40901e-06
GAMG: Solving for p, Initial residual = 0.000344377, Final residual = 6.71283e-07, No Iterations 19
time step continuity errors : sum local = 1.30622e-10, global = 6.13442e-12, cumulative = 6.40902e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0002685, Final residual = 8.85038e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000373578, Final residual = 6.31143e-06, No Iterations 6
ExecutionTime = 45.48 s ClockTime = 46 s
Time = 4.2775
Courant Number mean: 0.113221 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.50208e-05, Final residual = 8.32384e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.42358e-05, Final residual = 9.98293e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000383237, Final residual = 2.60428e-05, No Iterations 9
time step continuity errors : sum local = 5.05951e-09, global = -1.79274e-10, cumulative = 6.40884e-06
GAMG: Solving for p, Initial residual = 0.000328383, Final residual = 6.74317e-07, No Iterations 19
time step continuity errors : sum local = 1.31214e-10, global = 6.20873e-12, cumulative = 6.40884e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000267656, Final residual = 8.82833e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000372638, Final residual = 6.30398e-06, No Iterations 6
ExecutionTime = 45.51 s ClockTime = 46 s
Time = 4.28
Courant Number mean: 0.113223 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.4863e-05, Final residual = 8.27951e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.36626e-05, Final residual = 9.83158e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000390852, Final residual = 2.62815e-05, No Iterations 9
time step continuity errors : sum local = 5.10598e-09, global = -1.83541e-10, cumulative = 6.40866e-06
GAMG: Solving for p, Initial residual = 0.000330204, Final residual = 6.72603e-07, No Iterations 19
time step continuity errors : sum local = 1.30885e-10, global = 6.19958e-12, cumulative = 6.40867e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000266808, Final residual = 8.80675e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000371689, Final residual = 6.29749e-06, No Iterations 6
ExecutionTime = 45.54 s ClockTime = 46 s
Time = 4.2825
Courant Number mean: 0.113224 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.47015e-05, Final residual = 8.23754e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.33714e-05, Final residual = 9.80045e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000383824, Final residual = 2.60779e-05, No Iterations 9
time step continuity errors : sum local = 5.06663e-09, global = -1.8106e-10, cumulative = 6.40849e-06
GAMG: Solving for p, Initial residual = 0.00032757, Final residual = 6.71795e-07, No Iterations 19
time step continuity errors : sum local = 1.30732e-10, global = 6.20143e-12, cumulative = 6.40849e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000265957, Final residual = 8.78498e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000370733, Final residual = 6.29048e-06, No Iterations 6
ExecutionTime = 45.57 s ClockTime = 46 s
Time = 4.285
Courant Number mean: 0.113226 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.4545e-05, Final residual = 8.19642e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.29838e-05, Final residual = 9.72753e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000382616, Final residual = 2.60841e-05, No Iterations 9
time step continuity errors : sum local = 5.06802e-09, global = -1.81428e-10, cumulative = 6.40831e-06
GAMG: Solving for p, Initial residual = 0.000326328, Final residual = 6.70887e-07, No Iterations 19
time step continuity errors : sum local = 1.30559e-10, global = 6.20345e-12, cumulative = 6.40832e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000265103, Final residual = 8.76289e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000369768, Final residual = 6.28269e-06, No Iterations 6
ExecutionTime = 45.59 s ClockTime = 46 s
Time = 4.2875
Courant Number mean: 0.113228 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.43903e-05, Final residual = 8.15614e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.26305e-05, Final residual = 9.66961e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000379878, Final residual = 2.60014e-05, No Iterations 9
time step continuity errors : sum local = 5.05216e-09, global = -1.80669e-10, cumulative = 6.40814e-06
GAMG: Solving for p, Initial residual = 0.000324545, Final residual = 6.69805e-07, No Iterations 19
time step continuity errors : sum local = 1.30354e-10, global = 6.20268e-12, cumulative = 6.40814e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000264245, Final residual = 8.73933e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000368796, Final residual = 6.27506e-06, No Iterations 6
ExecutionTime = 45.62 s ClockTime = 46 s
Time = 4.29
Courant Number mean: 0.11323 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.42373e-05, Final residual = 8.11632e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.22661e-05, Final residual = 9.60639e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000378534, Final residual = 2.59496e-05, No Iterations 9
time step continuity errors : sum local = 5.04232e-09, global = -1.8034e-10, cumulative = 6.40796e-06
GAMG: Solving for p, Initial residual = 0.000322986, Final residual = 6.68681e-07, No Iterations 19
time step continuity errors : sum local = 1.3014e-10, global = 6.20178e-12, cumulative = 6.40797e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000263383, Final residual = 8.71632e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000367816, Final residual = 6.26647e-06, No Iterations 6
ExecutionTime = 45.65 s ClockTime = 46 s
Time = 4.2925
Courant Number mean: 0.113232 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.40856e-05, Final residual = 8.07715e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.19112e-05, Final residual = 9.54573e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000377677, Final residual = 2.58823e-05, No Iterations 9
time step continuity errors : sum local = 5.02946e-09, global = -1.79827e-10, cumulative = 6.40779e-06
GAMG: Solving for p, Initial residual = 0.000321362, Final residual = 6.67478e-07, No Iterations 19
time step continuity errors : sum local = 1.29911e-10, global = 6.19971e-12, cumulative = 6.4078e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000262518, Final residual = 8.69284e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00036683, Final residual = 6.25814e-06, No Iterations 6
ExecutionTime = 45.67 s ClockTime = 46 s
Time = 4.295
Courant Number mean: 0.113233 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.39359e-05, Final residual = 8.03856e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.15552e-05, Final residual = 9.48437e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000377063, Final residual = 2.58185e-05, No Iterations 9
time step continuity errors : sum local = 5.01731e-09, global = -1.79374e-10, cumulative = 6.40762e-06
GAMG: Solving for p, Initial residual = 0.000319782, Final residual = 6.66222e-07, No Iterations 19
time step continuity errors : sum local = 1.29672e-10, global = 6.1971e-12, cumulative = 6.40762e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00026165, Final residual = 8.66833e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000365838, Final residual = 6.24908e-06, No Iterations 6
ExecutionTime = 45.7 s ClockTime = 46 s
Time = 4.2975
Courant Number mean: 0.113235 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.37884e-05, Final residual = 8.00042e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.1201e-05, Final residual = 9.4235e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000374777, Final residual = 2.57519e-05, No Iterations 9
time step continuity errors : sum local = 5.00462e-09, global = -1.7889e-10, cumulative = 6.40744e-06
GAMG: Solving for p, Initial residual = 0.000318136, Final residual = 6.64918e-07, No Iterations 19
time step continuity errors : sum local = 1.29424e-10, global = 6.19381e-12, cumulative = 6.40745e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000260779, Final residual = 8.64362e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000364839, Final residual = 6.24024e-06, No Iterations 6
ExecutionTime = 45.73 s ClockTime = 46 s
Time = 4.3
Courant Number mean: 0.113237 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.36426e-05, Final residual = 7.96303e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.08484e-05, Final residual = 9.36293e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000373526, Final residual = 2.5686e-05, No Iterations 9
time step continuity errors : sum local = 4.99202e-09, global = -1.78417e-10, cumulative = 6.40727e-06
GAMG: Solving for p, Initial residual = 0.000316527, Final residual = 6.63583e-07, No Iterations 19
time step continuity errors : sum local = 1.29169e-10, global = 6.19026e-12, cumulative = 6.40728e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000259906, Final residual = 8.61866e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000363832, Final residual = 6.23148e-06, No Iterations 6
ExecutionTime = 45.79 s ClockTime = 46 s
Time = 4.3025
Courant Number mean: 0.113239 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.34986e-05, Final residual = 7.92622e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.04982e-05, Final residual = 9.30355e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000375886, Final residual = 2.5621e-05, No Iterations 9
time step continuity errors : sum local = 4.97961e-09, global = -1.77948e-10, cumulative = 6.4071e-06
GAMG: Solving for p, Initial residual = 0.000314922, Final residual = 6.62246e-07, No Iterations 19
time step continuity errors : sum local = 1.28913e-10, global = 6.18697e-12, cumulative = 6.40711e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000259029, Final residual = 8.59415e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000362819, Final residual = 6.22227e-06, No Iterations 6
ExecutionTime = 45.81 s ClockTime = 46 s
Time = 4.305
Courant Number mean: 0.11324 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.33556e-05, Final residual = 7.88999e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 7.01538e-05, Final residual = 9.24519e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000376343, Final residual = 2.55294e-05, No Iterations 9
time step continuity errors : sum local = 4.96204e-09, global = -1.77313e-10, cumulative = 6.40693e-06
GAMG: Solving for p, Initial residual = 0.000313639, Final residual = 6.60526e-07, No Iterations 19
time step continuity errors : sum local = 1.28583e-10, global = 6.17672e-12, cumulative = 6.40693e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000258149, Final residual = 8.56916e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000361801, Final residual = 6.21239e-06, No Iterations 6
ExecutionTime = 45.84 s ClockTime = 46 s
Time = 4.3075
Courant Number mean: 0.113242 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.32151e-05, Final residual = 7.85399e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.98101e-05, Final residual = 9.18692e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000367948, Final residual = 2.54695e-05, No Iterations 9
time step continuity errors : sum local = 4.95061e-09, global = -1.76891e-10, cumulative = 6.40676e-06
GAMG: Solving for p, Initial residual = 0.000311835, Final residual = 6.59232e-07, No Iterations 19
time step continuity errors : sum local = 1.28336e-10, global = 6.1743e-12, cumulative = 6.40676e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000257266, Final residual = 8.5439e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000360776, Final residual = 6.20219e-06, No Iterations 6
ExecutionTime = 45.87 s ClockTime = 46 s
Time = 4.31
Courant Number mean: 0.113244 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.30761e-05, Final residual = 7.81844e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.94733e-05, Final residual = 9.12981e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000365488, Final residual = 2.53995e-05, No Iterations 9
time step continuity errors : sum local = 4.93722e-09, global = -1.76396e-10, cumulative = 6.40659e-06
GAMG: Solving for p, Initial residual = 0.000310286, Final residual = 6.57768e-07, No Iterations 19
time step continuity errors : sum local = 1.28056e-10, global = 6.16947e-12, cumulative = 6.40659e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000256379, Final residual = 8.51789e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000359745, Final residual = 6.19147e-06, No Iterations 6
ExecutionTime = 45.9 s ClockTime = 46 s
Time = 4.3125
Courant Number mean: 0.113246 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.294e-05, Final residual = 7.7833e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.9139e-05, Final residual = 9.07303e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000363824, Final residual = 2.53251e-05, No Iterations 9
time step continuity errors : sum local = 4.92298e-09, global = -1.75875e-10, cumulative = 6.40642e-06
GAMG: Solving for p, Initial residual = 0.000308762, Final residual = 6.56204e-07, No Iterations 19
time step continuity errors : sum local = 1.27757e-10, global = 6.1629e-12, cumulative = 6.40642e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000255484, Final residual = 8.492e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000358708, Final residual = 6.18118e-06, No Iterations 6
ExecutionTime = 45.93 s ClockTime = 46 s
Time = 4.315
Courant Number mean: 0.113247 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.28046e-05, Final residual = 7.74859e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.88083e-05, Final residual = 9.01654e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000362253, Final residual = 2.52494e-05, No Iterations 9
time step continuity errors : sum local = 4.90849e-09, global = -1.75348e-10, cumulative = 6.40625e-06
GAMG: Solving for p, Initial residual = 0.000307235, Final residual = 6.54601e-07, No Iterations 19
time step continuity errors : sum local = 1.2745e-10, global = 6.15594e-12, cumulative = 6.40625e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000254589, Final residual = 8.46598e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000357666, Final residual = 6.16974e-06, No Iterations 6
ExecutionTime = 45.96 s ClockTime = 46 s
Time = 4.3175
Courant Number mean: 0.113249 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.26703e-05, Final residual = 7.71448e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.84791e-05, Final residual = 8.96026e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000360696, Final residual = 2.51729e-05, No Iterations 9
time step continuity errors : sum local = 4.89383e-09, global = -1.74818e-10, cumulative = 6.40608e-06
GAMG: Solving for p, Initial residual = 0.000305711, Final residual = 6.52966e-07, No Iterations 19
time step continuity errors : sum local = 1.27136e-10, global = 6.14857e-12, cumulative = 6.40609e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000253697, Final residual = 8.43891e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000356617, Final residual = 6.15784e-06, No Iterations 6
ExecutionTime = 45.99 s ClockTime = 46 s
Time = 4.32
Courant Number mean: 0.113251 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.25365e-05, Final residual = 7.68059e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.81517e-05, Final residual = 8.90437e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000359169, Final residual = 2.50953e-05, No Iterations 9
time step continuity errors : sum local = 4.87898e-09, global = -1.74283e-10, cumulative = 6.40591e-06
GAMG: Solving for p, Initial residual = 0.000304192, Final residual = 6.51302e-07, No Iterations 19
time step continuity errors : sum local = 1.26817e-10, global = 6.14087e-12, cumulative = 6.40592e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000252803, Final residual = 8.4123e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000355563, Final residual = 6.14583e-06, No Iterations 6
ExecutionTime = 46.01 s ClockTime = 46 s
Time = 4.3225
Courant Number mean: 0.113253 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.24047e-05, Final residual = 7.6471e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.78264e-05, Final residual = 8.84878e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000357664, Final residual = 2.50169e-05, No Iterations 9
time step continuity errors : sum local = 4.86395e-09, global = -1.73744e-10, cumulative = 6.40574e-06
GAMG: Solving for p, Initial residual = 0.000302682, Final residual = 6.49606e-07, No Iterations 19
time step continuity errors : sum local = 1.26492e-10, global = 6.13276e-12, cumulative = 6.40575e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000251906, Final residual = 8.38484e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000354504, Final residual = 6.13392e-06, No Iterations 6
ExecutionTime = 46.04 s ClockTime = 46 s
Time = 4.325
Courant Number mean: 0.113254 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.22753e-05, Final residual = 7.61376e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.75026e-05, Final residual = 8.79336e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000356157, Final residual = 2.49375e-05, No Iterations 9
time step continuity errors : sum local = 4.84874e-09, global = -1.732e-10, cumulative = 6.40558e-06
GAMG: Solving for p, Initial residual = 0.000301179, Final residual = 6.47876e-07, No Iterations 19
time step continuity errors : sum local = 1.2616e-10, global = 6.12419e-12, cumulative = 6.40558e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000251007, Final residual = 8.35771e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000353438, Final residual = 6.1219e-06, No Iterations 6
ExecutionTime = 46.07 s ClockTime = 46 s
Time = 4.3275
Courant Number mean: 0.113256 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.21469e-05, Final residual = 7.58089e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.71807e-05, Final residual = 8.73813e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000354645, Final residual = 2.4858e-05, No Iterations 9
time step continuity errors : sum local = 4.8335e-09, global = -1.72654e-10, cumulative = 6.40541e-06
GAMG: Solving for p, Initial residual = 0.000299681, Final residual = 6.46107e-07, No Iterations 19
time step continuity errors : sum local = 1.2582e-10, global = 6.11517e-12, cumulative = 6.40542e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000250106, Final residual = 8.33043e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000352367, Final residual = 6.10866e-06, No Iterations 6
ExecutionTime = 46.1 s ClockTime = 46 s
Time = 4.33
Courant Number mean: 0.113258 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.20193e-05, Final residual = 7.54863e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.68602e-05, Final residual = 8.6835e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00035316, Final residual = 2.47774e-05, No Iterations 9
time step continuity errors : sum local = 4.81806e-09, global = -1.72101e-10, cumulative = 6.40524e-06
GAMG: Solving for p, Initial residual = 0.00029818, Final residual = 6.44303e-07, No Iterations 19
time step continuity errors : sum local = 1.25474e-10, global = 6.1057e-12, cumulative = 6.40525e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000249203, Final residual = 8.30217e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000351291, Final residual = 6.09601e-06, No Iterations 6
ExecutionTime = 46.13 s ClockTime = 46 s
Time = 4.3325
Courant Number mean: 0.113259 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.18923e-05, Final residual = 7.51678e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.65417e-05, Final residual = 8.62927e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000352316, Final residual = 2.46959e-05, No Iterations 9
time step continuity errors : sum local = 4.80242e-09, global = -1.71542e-10, cumulative = 6.40508e-06
GAMG: Solving for p, Initial residual = 0.000296683, Final residual = 6.42467e-07, No Iterations 19
time step continuity errors : sum local = 1.25122e-10, global = 6.09572e-12, cumulative = 6.40508e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000248297, Final residual = 8.27449e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00035021, Final residual = 6.08341e-06, No Iterations 6
ExecutionTime = 46.16 s ClockTime = 46 s
Time = 4.335
Courant Number mean: 0.113261 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.17667e-05, Final residual = 7.48539e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.62236e-05, Final residual = 8.57498e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000350585, Final residual = 2.46131e-05, No Iterations 9
time step continuity errors : sum local = 4.78654e-09, global = -1.70979e-10, cumulative = 6.40491e-06
GAMG: Solving for p, Initial residual = 0.000295197, Final residual = 6.40603e-07, No Iterations 19
time step continuity errors : sum local = 1.24763e-10, global = 6.08537e-12, cumulative = 6.40492e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000247389, Final residual = 8.24567e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000349123, Final residual = 6.07037e-06, No Iterations 6
ExecutionTime = 46.19 s ClockTime = 46 s
Time = 4.3375
Courant Number mean: 0.113263 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.16435e-05, Final residual = 7.45491e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.59066e-05, Final residual = 8.52074e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000348881, Final residual = 2.45295e-05, No Iterations 9
time step continuity errors : sum local = 4.77051e-09, global = -1.70413e-10, cumulative = 6.40475e-06
GAMG: Solving for p, Initial residual = 0.000293718, Final residual = 6.38707e-07, No Iterations 19
time step continuity errors : sum local = 1.24399e-10, global = 6.07463e-12, cumulative = 6.40476e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000246478, Final residual = 8.21752e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000348032, Final residual = 6.05699e-06, No Iterations 6
ExecutionTime = 46.21 s ClockTime = 46 s
Time = 4.34
Courant Number mean: 0.113265 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.15223e-05, Final residual = 7.42528e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.55911e-05, Final residual = 8.46686e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000347258, Final residual = 2.44454e-05, No Iterations 9
time step continuity errors : sum local = 4.75437e-09, global = -1.69844e-10, cumulative = 6.40459e-06
GAMG: Solving for p, Initial residual = 0.000292249, Final residual = 6.36784e-07, No Iterations 19
time step continuity errors : sum local = 1.24029e-10, global = 6.06351e-12, cumulative = 6.40459e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000245563, Final residual = 8.1894e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000346935, Final residual = 6.04283e-06, No Iterations 6
ExecutionTime = 46.24 s ClockTime = 47 s
Time = 4.3425
Courant Number mean: 0.113266 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.14016e-05, Final residual = 7.39643e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.52768e-05, Final residual = 8.41333e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000345716, Final residual = 2.43615e-05, No Iterations 9
time step continuity errors : sum local = 4.73826e-09, global = -1.69281e-10, cumulative = 6.40442e-06
GAMG: Solving for p, Initial residual = 0.000290785, Final residual = 6.34864e-07, No Iterations 19
time step continuity errors : sum local = 1.2366e-10, global = 6.05242e-12, cumulative = 6.40443e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000244675, Final residual = 8.16119e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000345833, Final residual = 6.02901e-06, No Iterations 6
ExecutionTime = 46.27 s ClockTime = 47 s
Time = 4.345
Courant Number mean: 0.113268 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.12823e-05, Final residual = 7.36781e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.49666e-05, Final residual = 8.36023e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000345101, Final residual = 2.42745e-05, No Iterations 9
time step continuity errors : sum local = 4.72157e-09, global = -1.68701e-10, cumulative = 6.40426e-06
GAMG: Solving for p, Initial residual = 0.000289333, Final residual = 6.32881e-07, No Iterations 19
time step continuity errors : sum local = 1.23279e-10, global = 6.04044e-12, cumulative = 6.40427e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000243759, Final residual = 8.13215e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000344726, Final residual = 6.01524e-06, No Iterations 6
ExecutionTime = 46.3 s ClockTime = 47 s
Time = 4.3475
Courant Number mean: 0.11327 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.11651e-05, Final residual = 7.33961e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.466e-05, Final residual = 8.30751e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000344234, Final residual = 2.4188e-05, No Iterations 9
time step continuity errors : sum local = 4.70494e-09, global = -1.68124e-10, cumulative = 6.4041e-06
GAMG: Solving for p, Initial residual = 0.000287904, Final residual = 6.3087e-07, No Iterations 19
time step continuity errors : sum local = 1.22891e-10, global = 6.02803e-12, cumulative = 6.4041e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00024284, Final residual = 8.10315e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000343614, Final residual = 6.00099e-06, No Iterations 6
ExecutionTime = 46.32 s ClockTime = 47 s
Time = 4.35
Courant Number mean: 0.113271 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.10494e-05, Final residual = 7.31263e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.43558e-05, Final residual = 8.25488e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000342063, Final residual = 2.41007e-05, No Iterations 9
time step continuity errors : sum local = 4.68818e-09, global = -1.67549e-10, cumulative = 6.40394e-06
GAMG: Solving for p, Initial residual = 0.000286434, Final residual = 6.28829e-07, No Iterations 19
time step continuity errors : sum local = 1.22498e-10, global = 6.01522e-12, cumulative = 6.40394e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000241914, Final residual = 8.07348e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000342498, Final residual = 5.98551e-06, No Iterations 6
ExecutionTime = 46.35 s ClockTime = 47 s
Time = 4.3525
Courant Number mean: 0.113273 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.09354e-05, Final residual = 7.28645e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.40517e-05, Final residual = 8.20259e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000341998, Final residual = 2.4012e-05, No Iterations 9
time step continuity errors : sum local = 4.67113e-09, global = -1.66946e-10, cumulative = 6.40378e-06
GAMG: Solving for p, Initial residual = 0.000284995, Final residual = 6.26768e-07, No Iterations 19
time step continuity errors : sum local = 1.22101e-10, global = 6.00209e-12, cumulative = 6.40378e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000240986, Final residual = 8.04408e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000341377, Final residual = 5.97047e-06, No Iterations 6
ExecutionTime = 46.38 s ClockTime = 47 s
Time = 4.355
Courant Number mean: 0.113275 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.08238e-05, Final residual = 7.26075e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.37501e-05, Final residual = 8.15062e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000340265, Final residual = 2.39248e-05, No Iterations 9
time step continuity errors : sum local = 4.65438e-09, global = -1.66356e-10, cumulative = 6.40361e-06
GAMG: Solving for p, Initial residual = 0.000283576, Final residual = 6.24687e-07, No Iterations 19
time step continuity errors : sum local = 1.217e-10, global = 5.98863e-12, cumulative = 6.40362e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000240059, Final residual = 8.01454e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000340251, Final residual = 5.95524e-06, No Iterations 6
ExecutionTime = 46.41 s ClockTime = 47 s
Time = 4.3575
Courant Number mean: 0.113276 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.07141e-05, Final residual = 7.23529e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.34484e-05, Final residual = 8.09872e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000338636, Final residual = 2.38363e-05, No Iterations 9
time step continuity errors : sum local = 4.63735e-09, global = -1.65755e-10, cumulative = 6.40346e-06
GAMG: Solving for p, Initial residual = 0.000282165, Final residual = 6.2258e-07, No Iterations 19
time step continuity errors : sum local = 1.21294e-10, global = 5.97483e-12, cumulative = 6.40346e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000239132, Final residual = 7.98389e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000339122, Final residual = 5.94001e-06, No Iterations 6
ExecutionTime = 46.44 s ClockTime = 47 s
Time = 4.36
Courant Number mean: 0.113278 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.06047e-05, Final residual = 7.21036e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.31486e-05, Final residual = 8.04709e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000336994, Final residual = 2.37467e-05, No Iterations 9
time step continuity errors : sum local = 4.62013e-09, global = -1.65147e-10, cumulative = 6.4033e-06
GAMG: Solving for p, Initial residual = 0.00028076, Final residual = 6.20443e-07, No Iterations 19
time step continuity errors : sum local = 1.20883e-10, global = 5.96062e-12, cumulative = 6.4033e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000238205, Final residual = 7.95391e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000337989, Final residual = 5.92446e-06, No Iterations 6
ExecutionTime = 46.47 s ClockTime = 47 s
Time = 4.3625
Courant Number mean: 0.11328 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.04957e-05, Final residual = 7.18574e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.28518e-05, Final residual = 7.99593e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000335556, Final residual = 2.36568e-05, No Iterations 9
time step continuity errors : sum local = 4.60285e-09, global = -1.64536e-10, cumulative = 6.40314e-06
GAMG: Solving for p, Initial residual = 0.000279364, Final residual = 6.18277e-07, No Iterations 19
time step continuity errors : sum local = 1.20465e-10, global = 5.946e-12, cumulative = 6.40314e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000237277, Final residual = 7.92323e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000336852, Final residual = 9.99685e-06, No Iterations 5
ExecutionTime = 46.5 s ClockTime = 47 s
Time = 4.365
Courant Number mean: 0.113281 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.03889e-05, Final residual = 7.16265e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.25421e-05, Final residual = 7.94147e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000331618, Final residual = 2.35557e-05, No Iterations 9
time step continuity errors : sum local = 4.58336e-09, global = -1.63643e-10, cumulative = 6.40298e-06
GAMG: Solving for p, Initial residual = 0.000277475, Final residual = 6.14724e-07, No Iterations 19
time step continuity errors : sum local = 1.19777e-10, global = 5.91974e-12, cumulative = 6.40299e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000236293, Final residual = 7.88791e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00033567, Final residual = 9.9715e-06, No Iterations 5
ExecutionTime = 46.52 s ClockTime = 47 s
Time = 4.3675
Courant Number mean: 0.113283 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.02835e-05, Final residual = 7.13927e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.2251e-05, Final residual = 7.89204e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000330504, Final residual = 2.3448e-05, No Iterations 9
time step continuity errors : sum local = 4.56258e-09, global = -1.62869e-10, cumulative = 6.40282e-06
GAMG: Solving for p, Initial residual = 0.00027598, Final residual = 6.12629e-07, No Iterations 19
time step continuity errors : sum local = 1.19373e-10, global = 5.9055e-12, cumulative = 6.40283e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00023531, Final residual = 7.85278e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000334492, Final residual = 9.94665e-06, No Iterations 5
ExecutionTime = 46.55 s ClockTime = 47 s
Time = 4.37
Courant Number mean: 0.113284 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.01788e-05, Final residual = 7.11627e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.19599e-05, Final residual = 7.84216e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000329181, Final residual = 2.33632e-05, No Iterations 9
time step continuity errors : sum local = 4.54627e-09, global = -1.62309e-10, cumulative = 6.40267e-06
GAMG: Solving for p, Initial residual = 0.000274628, Final residual = 6.10483e-07, No Iterations 19
time step continuity errors : sum local = 1.18958e-10, global = 5.89081e-12, cumulative = 6.40267e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000234327, Final residual = 7.81726e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000333317, Final residual = 9.92094e-06, No Iterations 5
ExecutionTime = 46.58 s ClockTime = 47 s
Time = 4.3725
Courant Number mean: 0.113286 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 3.00752e-05, Final residual = 7.09387e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.16703e-05, Final residual = 7.79296e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000327576, Final residual = 2.32724e-05, No Iterations 9
time step continuity errors : sum local = 4.52879e-09, global = -1.61679e-10, cumulative = 6.40251e-06
GAMG: Solving for p, Initial residual = 0.000273278, Final residual = 6.08336e-07, No Iterations 19
time step continuity errors : sum local = 1.18544e-10, global = 5.8757e-12, cumulative = 6.40252e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000233344, Final residual = 7.78247e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000332144, Final residual = 9.89468e-06, No Iterations 5
ExecutionTime = 46.61 s ClockTime = 47 s
Time = 4.375
Courant Number mean: 0.113288 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.99718e-05, Final residual = 7.072e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.13818e-05, Final residual = 7.74401e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000326126, Final residual = 2.31828e-05, No Iterations 9
time step continuity errors : sum local = 4.51154e-09, global = -1.6107e-10, cumulative = 6.40236e-06
GAMG: Solving for p, Initial residual = 0.000271948, Final residual = 6.06174e-07, No Iterations 19
time step continuity errors : sum local = 1.18126e-10, global = 5.86052e-12, cumulative = 6.40236e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000232362, Final residual = 7.74787e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000330972, Final residual = 9.86742e-06, No Iterations 5
ExecutionTime = 46.63 s ClockTime = 47 s
Time = 4.3775
Courant Number mean: 0.113289 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.9871e-05, Final residual = 7.05009e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.10911e-05, Final residual = 7.6955e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000323451, Final residual = 2.30914e-05, No Iterations 9
time step continuity errors : sum local = 4.49393e-09, global = -1.60434e-10, cumulative = 6.4022e-06
GAMG: Solving for p, Initial residual = 0.000270637, Final residual = 6.03992e-07, No Iterations 19
time step continuity errors : sum local = 1.17705e-10, global = 5.84506e-12, cumulative = 6.40221e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000231381, Final residual = 7.71338e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000329801, Final residual = 9.84086e-06, No Iterations 5
ExecutionTime = 46.66 s ClockTime = 47 s
Time = 4.38
Courant Number mean: 0.113291 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.97726e-05, Final residual = 7.02902e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.08038e-05, Final residual = 7.64734e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000323263, Final residual = 2.29985e-05, No Iterations 9
time step continuity errors : sum local = 4.47602e-09, global = -1.59808e-10, cumulative = 6.40205e-06
GAMG: Solving for p, Initial residual = 0.000269384, Final residual = 6.01795e-07, No Iterations 19
time step continuity errors : sum local = 1.17281e-10, global = 5.82941e-12, cumulative = 6.40205e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000230401, Final residual = 7.67914e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000328631, Final residual = 9.81502e-06, No Iterations 5
ExecutionTime = 46.69 s ClockTime = 47 s
Time = 4.3825
Courant Number mean: 0.113292 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.96756e-05, Final residual = 7.00905e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.05203e-05, Final residual = 7.59955e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000323088, Final residual = 2.29073e-05, No Iterations 9
time step continuity errors : sum local = 4.45846e-09, global = -1.59163e-10, cumulative = 6.40189e-06
GAMG: Solving for p, Initial residual = 0.000268072, Final residual = 5.99587e-07, No Iterations 19
time step continuity errors : sum local = 1.16854e-10, global = 5.81359e-12, cumulative = 6.4019e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000229422, Final residual = 7.64445e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000327464, Final residual = 9.78804e-06, No Iterations 5
ExecutionTime = 46.71 s ClockTime = 47 s
Time = 4.385
Courant Number mean: 0.113294 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.95798e-05, Final residual = 6.98972e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 6.02417e-05, Final residual = 7.55209e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000320934, Final residual = 2.28142e-05, No Iterations 9
time step continuity errors : sum local = 4.44051e-09, global = -1.5854e-10, cumulative = 6.40174e-06
GAMG: Solving for p, Initial residual = 0.00026673, Final residual = 5.97359e-07, No Iterations 19
time step continuity errors : sum local = 1.16424e-10, global = 5.79752e-12, cumulative = 6.40175e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000228443, Final residual = 7.60989e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000326296, Final residual = 9.76063e-06, No Iterations 5
ExecutionTime = 46.74 s ClockTime = 47 s
Time = 4.3875
Courant Number mean: 0.113296 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.94854e-05, Final residual = 6.97082e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.99661e-05, Final residual = 7.50561e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000319131, Final residual = 2.27202e-05, No Iterations 9
time step continuity errors : sum local = 4.42239e-09, global = -1.57918e-10, cumulative = 6.40159e-06
GAMG: Solving for p, Initial residual = 0.000265369, Final residual = 5.95123e-07, No Iterations 19
time step continuity errors : sum local = 1.15992e-10, global = 5.78138e-12, cumulative = 6.40159e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000227465, Final residual = 7.57589e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000325127, Final residual = 9.73397e-06, No Iterations 5
ExecutionTime = 46.77 s ClockTime = 47 s
Time = 4.39
Courant Number mean: 0.113297 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.9393e-05, Final residual = 6.95294e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.96916e-05, Final residual = 7.45983e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000317543, Final residual = 2.2627e-05, No Iterations 9
time step continuity errors : sum local = 4.40443e-09, global = -1.57291e-10, cumulative = 6.40144e-06
GAMG: Solving for p, Initial residual = 0.000264064, Final residual = 5.92879e-07, No Iterations 19
time step continuity errors : sum local = 1.15558e-10, global = 5.76514e-12, cumulative = 6.40144e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000226486, Final residual = 7.54134e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000323958, Final residual = 9.70629e-06, No Iterations 5
ExecutionTime = 46.79 s ClockTime = 47 s
Time = 4.3925
Courant Number mean: 0.113299 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.93013e-05, Final residual = 6.93551e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.94203e-05, Final residual = 7.41462e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000316035, Final residual = 2.25334e-05, No Iterations 9
time step continuity errors : sum local = 4.38637e-09, global = -1.56661e-10, cumulative = 6.40129e-06
GAMG: Solving for p, Initial residual = 0.000262769, Final residual = 5.90624e-07, No Iterations 19
time step continuity errors : sum local = 1.15123e-10, global = 5.74875e-12, cumulative = 6.40129e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000225509, Final residual = 7.508e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000322789, Final residual = 9.67866e-06, No Iterations 5
ExecutionTime = 46.82 s ClockTime = 47 s
Time = 4.395
Courant Number mean: 0.1133 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.92111e-05, Final residual = 6.91828e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.91516e-05, Final residual = 7.37007e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00031458, Final residual = 2.24393e-05, No Iterations 9
time step continuity errors : sum local = 4.36823e-09, global = -1.56032e-10, cumulative = 6.40114e-06
GAMG: Solving for p, Initial residual = 0.000261486, Final residual = 5.8836e-07, No Iterations 19
time step continuity errors : sum local = 1.14685e-10, global = 5.73221e-12, cumulative = 6.40114e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000224533, Final residual = 7.47369e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000321619, Final residual = 9.65108e-06, No Iterations 5
ExecutionTime = 46.84 s ClockTime = 47 s
Time = 4.3975
Courant Number mean: 0.113302 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.91225e-05, Final residual = 6.90144e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.88849e-05, Final residual = 7.32663e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000313109, Final residual = 2.23447e-05, No Iterations 9
time step continuity errors : sum local = 4.35002e-09, global = -1.55399e-10, cumulative = 6.40099e-06
GAMG: Solving for p, Initial residual = 0.00026021, Final residual = 5.86081e-07, No Iterations 19
time step continuity errors : sum local = 1.14245e-10, global = 5.71551e-12, cumulative = 6.40099e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000223557, Final residual = 7.43913e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000320449, Final residual = 9.62226e-06, No Iterations 5
ExecutionTime = 46.87 s ClockTime = 47 s
Time = 4.4
Courant Number mean: 0.113304 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.9035e-05, Final residual = 6.88525e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.86209e-05, Final residual = 7.28397e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000311916, Final residual = 2.22498e-05, No Iterations 9
time step continuity errors : sum local = 4.33172e-09, global = -1.54765e-10, cumulative = 6.40084e-06
GAMG: Solving for p, Initial residual = 0.000258941, Final residual = 5.83788e-07, No Iterations 19
time step continuity errors : sum local = 1.13802e-10, global = 5.69863e-12, cumulative = 6.40084e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000222584, Final residual = 7.40544e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000319277, Final residual = 9.59437e-06, No Iterations 5
ExecutionTime = 46.92 s ClockTime = 47 s
Time = 4.4025
Courant Number mean: 0.113305 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.89482e-05, Final residual = 6.86918e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.83602e-05, Final residual = 7.24206e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000312201, Final residual = 2.2161e-05, No Iterations 9
time step continuity errors : sum local = 4.31463e-09, global = -1.5413e-10, cumulative = 6.40069e-06
GAMG: Solving for p, Initial residual = 0.000257652, Final residual = 5.81359e-07, No Iterations 19
time step continuity errors : sum local = 1.13332e-10, global = 5.68188e-12, cumulative = 6.40069e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000221611, Final residual = 7.3718e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000318105, Final residual = 9.56624e-06, No Iterations 5
ExecutionTime = 46.94 s ClockTime = 47 s
Time = 4.405
Courant Number mean: 0.113307 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.88621e-05, Final residual = 6.85322e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.81e-05, Final residual = 7.20082e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000309747, Final residual = 2.20568e-05, No Iterations 9
time step continuity errors : sum local = 4.29451e-09, global = -1.53456e-10, cumulative = 6.40054e-06
GAMG: Solving for p, Initial residual = 0.000256429, Final residual = 5.7912e-07, No Iterations 19
time step continuity errors : sum local = 1.12899e-10, global = 5.66449e-12, cumulative = 6.40055e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000220639, Final residual = 7.33825e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000316931, Final residual = 9.53787e-06, No Iterations 5
ExecutionTime = 46.96 s ClockTime = 47 s
Time = 4.4075
Courant Number mean: 0.113308 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.87766e-05, Final residual = 6.83752e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.78426e-05, Final residual = 7.16013e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.0003084, Final residual = 2.19596e-05, No Iterations 9
time step continuity errors : sum local = 4.27576e-09, global = -1.52819e-10, cumulative = 6.40039e-06
GAMG: Solving for p, Initial residual = 0.000255239, Final residual = 5.76823e-07, No Iterations 19
time step continuity errors : sum local = 1.12455e-10, global = 5.64711e-12, cumulative = 6.4004e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000219668, Final residual = 7.30467e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000315757, Final residual = 9.50879e-06, No Iterations 5
ExecutionTime = 46.99 s ClockTime = 47 s
Time = 4.41
Courant Number mean: 0.11331 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.86919e-05, Final residual = 6.82188e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.75897e-05, Final residual = 7.11973e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000307031, Final residual = 2.18654e-05, No Iterations 9
time step continuity errors : sum local = 4.25759e-09, global = -1.52187e-10, cumulative = 6.40025e-06
GAMG: Solving for p, Initial residual = 0.000254015, Final residual = 5.74482e-07, No Iterations 19
time step continuity errors : sum local = 1.12003e-10, global = 5.62944e-12, cumulative = 6.40025e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000218697, Final residual = 7.27111e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000314583, Final residual = 9.48064e-06, No Iterations 5
ExecutionTime = 47.02 s ClockTime = 47 s
Time = 4.4125
Courant Number mean: 0.113311 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.86086e-05, Final residual = 6.80619e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.73358e-05, Final residual = 7.07985e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000304738, Final residual = 2.17672e-05, No Iterations 9
time step continuity errors : sum local = 4.23864e-09, global = -1.51539e-10, cumulative = 6.4001e-06
GAMG: Solving for p, Initial residual = 0.000252707, Final residual = 5.72128e-07, No Iterations 19
time step continuity errors : sum local = 1.11548e-10, global = 5.61162e-12, cumulative = 6.40011e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000217728, Final residual = 7.2376e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000313408, Final residual = 9.45123e-06, No Iterations 5
ExecutionTime = 47.05 s ClockTime = 47 s
Time = 4.415
Courant Number mean: 0.113313 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.85254e-05, Final residual = 6.79075e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.70853e-05, Final residual = 7.04036e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000303371, Final residual = 2.16702e-05, No Iterations 9
time step continuity errors : sum local = 4.21992e-09, global = -1.50891e-10, cumulative = 6.39996e-06
GAMG: Solving for p, Initial residual = 0.000251494, Final residual = 5.69737e-07, No Iterations 19
time step continuity errors : sum local = 1.11085e-10, global = 5.59331e-12, cumulative = 6.39996e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000216761, Final residual = 7.2041e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000312231, Final residual = 9.42192e-06, No Iterations 5
ExecutionTime = 47.07 s ClockTime = 47 s
Time = 4.4175
Courant Number mean: 0.113314 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.84424e-05, Final residual = 6.77542e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.68361e-05, Final residual = 7.00141e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000302116, Final residual = 2.15726e-05, No Iterations 9
time step continuity errors : sum local = 4.2011e-09, global = -1.50245e-10, cumulative = 6.39981e-06
GAMG: Solving for p, Initial residual = 0.000250273, Final residual = 5.6736e-07, No Iterations 19
time step continuity errors : sum local = 1.10625e-10, global = 5.57521e-12, cumulative = 6.39982e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000215794, Final residual = 7.17022e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000311053, Final residual = 9.39269e-06, No Iterations 5
ExecutionTime = 47.1 s ClockTime = 47 s
Time = 4.42
Courant Number mean: 0.113316 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.83599e-05, Final residual = 6.76003e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.65891e-05, Final residual = 6.96323e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000300846, Final residual = 2.14746e-05, No Iterations 9
time step continuity errors : sum local = 4.18219e-09, global = -1.49594e-10, cumulative = 6.39967e-06
GAMG: Solving for p, Initial residual = 0.000249055, Final residual = 5.64963e-07, No Iterations 19
time step continuity errors : sum local = 1.10162e-10, global = 5.55679e-12, cumulative = 6.39967e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000214829, Final residual = 7.137e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000309873, Final residual = 9.36254e-06, No Iterations 5
ExecutionTime = 47.12 s ClockTime = 47 s
Time = 4.4225
Courant Number mean: 0.113317 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.8278e-05, Final residual = 6.74492e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.63455e-05, Final residual = 6.9252e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000299543, Final residual = 2.13762e-05, No Iterations 9
time step continuity errors : sum local = 4.16319e-09, global = -1.48942e-10, cumulative = 6.39952e-06
GAMG: Solving for p, Initial residual = 0.000247848, Final residual = 5.62554e-07, No Iterations 19
time step continuity errors : sum local = 1.09696e-10, global = 5.53816e-12, cumulative = 6.39953e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000213865, Final residual = 7.10326e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000308692, Final residual = 9.33269e-06, No Iterations 5
ExecutionTime = 47.15 s ClockTime = 47 s
Time = 4.425
Courant Number mean: 0.113319 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.81969e-05, Final residual = 6.73009e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.61033e-05, Final residual = 6.88767e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000298278, Final residual = 2.12774e-05, No Iterations 9
time step continuity errors : sum local = 4.1441e-09, global = -1.48287e-10, cumulative = 6.39938e-06
GAMG: Solving for p, Initial residual = 0.000246645, Final residual = 5.60134e-07, No Iterations 19
time step continuity errors : sum local = 1.09227e-10, global = 5.51934e-12, cumulative = 6.39939e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000212902, Final residual = 7.06893e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00030751, Final residual = 9.30314e-06, No Iterations 5
ExecutionTime = 47.18 s ClockTime = 47 s
Time = 4.4275
Courant Number mean: 0.11332 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.81168e-05, Final residual = 6.71537e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.58629e-05, Final residual = 6.85047e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000296973, Final residual = 2.11782e-05, No Iterations 9
time step continuity errors : sum local = 4.12496e-09, global = -1.4763e-10, cumulative = 6.39924e-06
GAMG: Solving for p, Initial residual = 0.000245439, Final residual = 5.57699e-07, No Iterations 19
time step continuity errors : sum local = 1.08756e-10, global = 5.50031e-12, cumulative = 6.39924e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00021194, Final residual = 7.03575e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000306328, Final residual = 9.2732e-06, No Iterations 5
ExecutionTime = 47.22 s ClockTime = 48 s
Time = 4.43
Courant Number mean: 0.113322 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.80365e-05, Final residual = 6.7009e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.5625e-05, Final residual = 6.81381e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000295696, Final residual = 2.10787e-05, No Iterations 9
time step continuity errors : sum local = 4.10576e-09, global = -1.46971e-10, cumulative = 6.3991e-06
GAMG: Solving for p, Initial residual = 0.000244234, Final residual = 5.55252e-07, No Iterations 19
time step continuity errors : sum local = 1.08283e-10, global = 5.48108e-12, cumulative = 6.3991e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00021098, Final residual = 7.00248e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000305144, Final residual = 9.24309e-06, No Iterations 5
ExecutionTime = 47.24 s ClockTime = 48 s
Time = 4.4325
Courant Number mean: 0.113323 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.79566e-05, Final residual = 6.6865e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.53901e-05, Final residual = 6.77741e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000296563, Final residual = 2.09821e-05, No Iterations 9
time step continuity errors : sum local = 4.08711e-09, global = -1.46323e-10, cumulative = 6.39896e-06
GAMG: Solving for p, Initial residual = 0.000243044, Final residual = 5.52777e-07, No Iterations 19
time step continuity errors : sum local = 1.07803e-10, global = 5.46169e-12, cumulative = 6.39896e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000210021, Final residual = 6.96926e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00030396, Final residual = 9.21237e-06, No Iterations 5
ExecutionTime = 47.27 s ClockTime = 48 s
Time = 4.435
Courant Number mean: 0.113325 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.78773e-05, Final residual = 6.67214e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.5156e-05, Final residual = 6.74139e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000302726, Final residual = 2.08908e-05, No Iterations 9
time step continuity errors : sum local = 4.06948e-09, global = -1.45672e-10, cumulative = 6.39882e-06
GAMG: Solving for p, Initial residual = 0.000241884, Final residual = 9.95324e-07, No Iterations 18
time step continuity errors : sum local = 1.94115e-10, global = -1.58304e-11, cumulative = 6.3988e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000209064, Final residual = 6.93583e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000302774, Final residual = 9.18181e-06, No Iterations 5
ExecutionTime = 47.3 s ClockTime = 48 s
Time = 4.4375
Courant Number mean: 0.113326 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.77992e-05, Final residual = 6.65795e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.49212e-05, Final residual = 6.70569e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00029765, Final residual = 2.07642e-05, No Iterations 9
time step continuity errors : sum local = 4.04498e-09, global = -1.44861e-10, cumulative = 6.39866e-06
GAMG: Solving for p, Initial residual = 0.000240682, Final residual = 9.90013e-07, No Iterations 18
time step continuity errors : sum local = 1.93086e-10, global = -1.57448e-11, cumulative = 6.39864e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000208108, Final residual = 6.90238e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000301588, Final residual = 9.15123e-06, No Iterations 5
ExecutionTime = 47.32 s ClockTime = 48 s
Time = 4.44
Courant Number mean: 0.113328 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.77213e-05, Final residual = 6.64377e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.46899e-05, Final residual = 6.66985e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000294205, Final residual = 2.06739e-05, No Iterations 9
time step continuity errors : sum local = 4.02755e-09, global = -1.44264e-10, cumulative = 6.3985e-06
GAMG: Solving for p, Initial residual = 0.000239452, Final residual = 9.99293e-07, No Iterations 17
time step continuity errors : sum local = 1.94902e-10, global = 9.09215e-12, cumulative = 6.39851e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000207154, Final residual = 6.86862e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000300401, Final residual = 9.12033e-06, No Iterations 5
ExecutionTime = 47.35 s ClockTime = 48 s
Time = 4.4425
Courant Number mean: 0.113329 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.76466e-05, Final residual = 6.6306e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.44571e-05, Final residual = 6.63411e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000291272, Final residual = 2.04937e-05, No Iterations 9
time step continuity errors : sum local = 3.99262e-09, global = -1.43095e-10, cumulative = 6.39836e-06
GAMG: Solving for p, Initial residual = 0.000238081, Final residual = 9.95224e-07, No Iterations 17
time step continuity errors : sum local = 1.94115e-10, global = 9.05882e-12, cumulative = 6.39837e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000206201, Final residual = 6.83532e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000299213, Final residual = 9.08864e-06, No Iterations 5
ExecutionTime = 47.38 s ClockTime = 48 s
Time = 4.445
Courant Number mean: 0.113331 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.75694e-05, Final residual = 6.61607e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.42296e-05, Final residual = 6.5992e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000290002, Final residual = 2.04196e-05, No Iterations 9
time step continuity errors : sum local = 3.97835e-09, global = -1.42603e-10, cumulative = 6.39823e-06
GAMG: Solving for p, Initial residual = 0.000236904, Final residual = 9.90479e-07, No Iterations 17
time step continuity errors : sum local = 1.93196e-10, global = 9.01934e-12, cumulative = 6.39824e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00020525, Final residual = 6.80138e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000298024, Final residual = 9.0564e-06, No Iterations 5
ExecutionTime = 47.4 s ClockTime = 48 s
Time = 4.4475
Courant Number mean: 0.113332 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.74932e-05, Final residual = 6.60233e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.40015e-05, Final residual = 6.56439e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000288541, Final residual = 2.03152e-05, No Iterations 9
time step continuity errors : sum local = 3.95818e-09, global = -1.41903e-10, cumulative = 6.3981e-06
GAMG: Solving for p, Initial residual = 0.000235724, Final residual = 9.86018e-07, No Iterations 17
time step continuity errors : sum local = 1.92333e-10, global = 8.98217e-12, cumulative = 6.3981e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0002043, Final residual = 6.76791e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000296835, Final residual = 9.02506e-06, No Iterations 5
ExecutionTime = 47.43 s ClockTime = 48 s
Time = 4.45
Courant Number mean: 0.113334 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.74174e-05, Final residual = 6.58843e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.37731e-05, Final residual = 6.52964e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000288619, Final residual = 2.02173e-05, No Iterations 9
time step continuity errors : sum local = 3.93927e-09, global = -1.4127e-10, cumulative = 6.39796e-06
GAMG: Solving for p, Initial residual = 0.000234561, Final residual = 9.81539e-07, No Iterations 17
time step continuity errors : sum local = 1.91465e-10, global = 8.94518e-12, cumulative = 6.39797e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000203351, Final residual = 6.73436e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000295645, Final residual = 8.99338e-06, No Iterations 5
ExecutionTime = 47.46 s ClockTime = 48 s
Time = 4.4525
Courant Number mean: 0.113335 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.73423e-05, Final residual = 6.57469e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.3547e-05, Final residual = 6.4952e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00028909, Final residual = 2.01175e-05, No Iterations 9
time step continuity errors : sum local = 3.92e-09, global = -1.40626e-10, cumulative = 6.39783e-06
GAMG: Solving for p, Initial residual = 0.000233453, Final residual = 9.77045e-07, No Iterations 17
time step continuity errors : sum local = 1.90596e-10, global = 8.90811e-12, cumulative = 6.39784e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000202403, Final residual = 6.701e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000294454, Final residual = 8.96178e-06, No Iterations 5
ExecutionTime = 47.49 s ClockTime = 48 s
Time = 4.455
Courant Number mean: 0.113337 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.72678e-05, Final residual = 6.5609e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.3322e-05, Final residual = 6.461e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00029103, Final residual = 2.00182e-05, No Iterations 9
time step continuity errors : sum local = 3.90083e-09, global = -1.39995e-10, cumulative = 6.3977e-06
GAMG: Solving for p, Initial residual = 0.000232263, Final residual = 9.72549e-07, No Iterations 17
time step continuity errors : sum local = 1.89727e-10, global = 8.87106e-12, cumulative = 6.39771e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000201457, Final residual = 6.66729e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000293262, Final residual = 8.92968e-06, No Iterations 5
ExecutionTime = 47.53 s ClockTime = 48 s
Time = 4.4575
Courant Number mean: 0.113338 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.71933e-05, Final residual = 6.54735e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.31037e-05, Final residual = 6.42713e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000288293, Final residual = 1.9913e-05, No Iterations 9
time step continuity errors : sum local = 3.88053e-09, global = -1.39286e-10, cumulative = 6.39757e-06
GAMG: Solving for p, Initial residual = 0.000231074, Final residual = 9.68019e-07, No Iterations 17
time step continuity errors : sum local = 1.8885e-10, global = 8.8335e-12, cumulative = 6.39758e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000200512, Final residual = 6.63329e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000292069, Final residual = 8.89743e-06, No Iterations 5
ExecutionTime = 47.55 s ClockTime = 48 s
Time = 4.46
Courant Number mean: 0.113339 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.71191e-05, Final residual = 6.53391e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.28866e-05, Final residual = 6.39371e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000286985, Final residual = 1.98104e-05, No Iterations 9
time step continuity errors : sum local = 3.86072e-09, global = -1.38608e-10, cumulative = 6.39744e-06
GAMG: Solving for p, Initial residual = 0.000229917, Final residual = 9.63489e-07, No Iterations 17
time step continuity errors : sum local = 1.87974e-10, global = 8.79593e-12, cumulative = 6.39745e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000199569, Final residual = 6.59906e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000290875, Final residual = 8.86465e-06, No Iterations 5
ExecutionTime = 47.58 s ClockTime = 48 s
Time = 4.4625
Courant Number mean: 0.113341 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.70447e-05, Final residual = 6.52053e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.26677e-05, Final residual = 6.3607e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000284796, Final residual = 1.97049e-05, No Iterations 9
time step continuity errors : sum local = 3.84033e-09, global = -1.37902e-10, cumulative = 6.39731e-06
GAMG: Solving for p, Initial residual = 0.000228792, Final residual = 9.58932e-07, No Iterations 17
time step continuity errors : sum local = 1.87092e-10, global = 8.75806e-12, cumulative = 6.39732e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000198635, Final residual = 6.56607e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00028968, Final residual = 8.83223e-06, No Iterations 5
ExecutionTime = 47.6 s ClockTime = 48 s
Time = 4.465
Courant Number mean: 0.113342 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.69705e-05, Final residual = 6.50737e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.24438e-05, Final residual = 6.32771e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00028128, Final residual = 1.96006e-05, No Iterations 9
time step continuity errors : sum local = 3.82017e-09, global = -1.37184e-10, cumulative = 6.39718e-06
GAMG: Solving for p, Initial residual = 0.000227654, Final residual = 9.54361e-07, No Iterations 17
time step continuity errors : sum local = 1.86207e-10, global = 8.71991e-12, cumulative = 6.39719e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000197695, Final residual = 6.53219e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000288484, Final residual = 8.79887e-06, No Iterations 5
ExecutionTime = 47.63 s ClockTime = 48 s
Time = 4.4675
Courant Number mean: 0.113344 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.68972e-05, Final residual = 6.49435e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.22224e-05, Final residual = 6.29477e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000278816, Final residual = 1.94961e-05, No Iterations 9
time step continuity errors : sum local = 3.79996e-09, global = -1.36498e-10, cumulative = 6.39706e-06
GAMG: Solving for p, Initial residual = 0.000226438, Final residual = 9.49789e-07, No Iterations 17
time step continuity errors : sum local = 1.85321e-10, global = 8.68185e-12, cumulative = 6.39706e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000196764, Final residual = 6.49907e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000287287, Final residual = 8.76615e-06, No Iterations 5
ExecutionTime = 47.66 s ClockTime = 48 s
Time = 4.47
Courant Number mean: 0.113345 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.68245e-05, Final residual = 6.48144e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.2005e-05, Final residual = 6.26203e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000277337, Final residual = 1.93926e-05, No Iterations 9
time step continuity errors : sum local = 3.77994e-09, global = -1.35815e-10, cumulative = 6.39693e-06
GAMG: Solving for p, Initial residual = 0.000225299, Final residual = 9.45201e-07, No Iterations 17
time step continuity errors : sum local = 1.84433e-10, global = 8.6436e-12, cumulative = 6.39694e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000195827, Final residual = 6.46533e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.00028609, Final residual = 8.7332e-06, No Iterations 5
ExecutionTime = 47.69 s ClockTime = 48 s
Time = 4.4725
Courant Number mean: 0.113346 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.67524e-05, Final residual = 6.46862e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.1789e-05, Final residual = 6.22984e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00027697, Final residual = 1.92899e-05, No Iterations 9
time step continuity errors : sum local = 3.7601e-09, global = -1.35148e-10, cumulative = 6.3968e-06
GAMG: Solving for p, Initial residual = 0.000224158, Final residual = 9.40606e-07, No Iterations 17
time step continuity errors : sum local = 1.83542e-10, global = 8.60526e-12, cumulative = 6.39681e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000194891, Final residual = 6.43197e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000284891, Final residual = 8.69939e-06, No Iterations 5
ExecutionTime = 47.71 s ClockTime = 48 s
Time = 4.475
Courant Number mean: 0.113348 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.66809e-05, Final residual = 6.45587e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.15745e-05, Final residual = 6.19786e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000276197, Final residual = 1.91863e-05, No Iterations 9
time step continuity errors : sum local = 3.74007e-09, global = -1.34471e-10, cumulative = 6.39668e-06
GAMG: Solving for p, Initial residual = 0.000223038, Final residual = 9.35997e-07, No Iterations 17
time step continuity errors : sum local = 1.82649e-10, global = 8.56674e-12, cumulative = 6.39668e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000193957, Final residual = 6.39864e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000283693, Final residual = 8.66593e-06, No Iterations 5
ExecutionTime = 47.74 s ClockTime = 48 s
Time = 4.4775
Courant Number mean: 0.113349 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.66101e-05, Final residual = 6.44327e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.13614e-05, Final residual = 6.16594e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000277238, Final residual = 1.90848e-05, No Iterations 9
time step continuity errors : sum local = 3.72045e-09, global = -1.33813e-10, cumulative = 6.39655e-06
GAMG: Solving for p, Initial residual = 0.000221954, Final residual = 9.31375e-07, No Iterations 17
time step continuity errors : sum local = 1.81754e-10, global = 8.52806e-12, cumulative = 6.39656e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000193025, Final residual = 6.36525e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000282494, Final residual = 8.63295e-06, No Iterations 5
ExecutionTime = 47.77 s ClockTime = 48 s
Time = 4.48
Courant Number mean: 0.113351 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.65398e-05, Final residual = 6.43063e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.11549e-05, Final residual = 6.13416e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.0002774, Final residual = 1.89813e-05, No Iterations 9
time step continuity errors : sum local = 3.70045e-09, global = -1.33139e-10, cumulative = 6.39643e-06
GAMG: Solving for p, Initial residual = 0.000220863, Final residual = 9.26744e-07, No Iterations 17
time step continuity errors : sum local = 1.80857e-10, global = 8.48934e-12, cumulative = 6.39643e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000192094, Final residual = 6.33198e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000281295, Final residual = 8.5989e-06, No Iterations 5
ExecutionTime = 47.8 s ClockTime = 48 s
Time = 4.4825
Courant Number mean: 0.113352 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.64694e-05, Final residual = 6.41813e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.09484e-05, Final residual = 6.10271e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000278535, Final residual = 1.88771e-05, No Iterations 9
time step continuity errors : sum local = 3.6803e-09, global = -1.32451e-10, cumulative = 6.3963e-06
GAMG: Solving for p, Initial residual = 0.000219757, Final residual = 9.22108e-07, No Iterations 17
time step continuity errors : sum local = 1.79959e-10, global = 8.45048e-12, cumulative = 6.39631e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000191164, Final residual = 6.29883e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000280095, Final residual = 8.5648e-06, No Iterations 5
ExecutionTime = 47.82 s ClockTime = 48 s
Time = 4.485
Courant Number mean: 0.113353 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.63994e-05, Final residual = 6.40553e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.07415e-05, Final residual = 6.07142e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000281116, Final residual = 1.87722e-05, No Iterations 9
time step continuity errors : sum local = 3.66002e-09, global = -1.3176e-10, cumulative = 6.39618e-06
GAMG: Solving for p, Initial residual = 0.000218719, Final residual = 9.17467e-07, No Iterations 17
time step continuity errors : sum local = 1.7906e-10, global = 8.4115e-12, cumulative = 6.39619e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000190236, Final residual = 6.26566e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000278895, Final residual = 8.53073e-06, No Iterations 5
ExecutionTime = 47.85 s ClockTime = 48 s
Time = 4.4875
Courant Number mean: 0.113355 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.63295e-05, Final residual = 6.39311e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.05367e-05, Final residual = 6.04023e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000279923, Final residual = 1.86675e-05, No Iterations 9
time step continuity errors : sum local = 3.63975e-09, global = -1.31074e-10, cumulative = 6.39606e-06
GAMG: Solving for p, Initial residual = 0.000217628, Final residual = 9.12816e-07, No Iterations 17
time step continuity errors : sum local = 1.78158e-10, global = 8.37249e-12, cumulative = 6.39606e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00018931, Final residual = 6.23223e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000277694, Final residual = 8.49686e-06, No Iterations 5
ExecutionTime = 47.88 s ClockTime = 48 s
Time = 4.49
Courant Number mean: 0.113356 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.62599e-05, Final residual = 6.38075e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.03317e-05, Final residual = 6.00891e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000275061, Final residual = 1.85632e-05, No Iterations 9
time step continuity errors : sum local = 3.61958e-09, global = -1.30401e-10, cumulative = 6.39593e-06
GAMG: Solving for p, Initial residual = 0.000216574, Final residual = 9.0816e-07, No Iterations 17
time step continuity errors : sum local = 1.77256e-10, global = 8.33352e-12, cumulative = 6.39594e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000188386, Final residual = 6.19901e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000276494, Final residual = 8.46254e-06, No Iterations 5
ExecutionTime = 47.91 s ClockTime = 48 s
Time = 4.4925
Courant Number mean: 0.113357 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.61908e-05, Final residual = 6.36844e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 5.01182e-05, Final residual = 5.97775e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000271493, Final residual = 1.84548e-05, No Iterations 9
time step continuity errors : sum local = 3.5986e-09, global = -1.29673e-10, cumulative = 6.39581e-06
GAMG: Solving for p, Initial residual = 0.000215515, Final residual = 9.03474e-07, No Iterations 17
time step continuity errors : sum local = 1.76348e-10, global = 8.29393e-12, cumulative = 6.39582e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000187463, Final residual = 6.16591e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000275295, Final residual = 8.42878e-06, No Iterations 5
ExecutionTime = 47.93 s ClockTime = 48 s
Time = 4.495
Courant Number mean: 0.113359 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.6122e-05, Final residual = 6.35622e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.9906e-05, Final residual = 5.94669e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000268369, Final residual = 1.83505e-05, No Iterations 9
time step continuity errors : sum local = 3.57839e-09, global = -1.28981e-10, cumulative = 6.39569e-06
GAMG: Solving for p, Initial residual = 0.000214392, Final residual = 8.98725e-07, No Iterations 17
time step continuity errors : sum local = 1.75426e-10, global = 8.2532e-12, cumulative = 6.3957e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000186542, Final residual = 6.13283e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000274095, Final residual = 8.39378e-06, No Iterations 5
ExecutionTime = 47.96 s ClockTime = 48 s
Time = 4.4975
Courant Number mean: 0.11336 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.60538e-05, Final residual = 6.34406e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.96918e-05, Final residual = 5.91659e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000268967, Final residual = 1.82441e-05, No Iterations 9
time step continuity errors : sum local = 3.55779e-09, global = -1.28293e-10, cumulative = 6.39557e-06
GAMG: Solving for p, Initial residual = 0.000213171, Final residual = 8.94406e-07, No Iterations 17
time step continuity errors : sum local = 1.74589e-10, global = 8.21944e-12, cumulative = 6.39558e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000185623, Final residual = 6.09979e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000272896, Final residual = 8.35893e-06, No Iterations 5
ExecutionTime = 47.99 s ClockTime = 48 s
Time = 4.5
Courant Number mean: 0.113361 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.59857e-05, Final residual = 6.33206e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.94871e-05, Final residual = 5.88749e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.0002778, Final residual = 1.81396e-05, No Iterations 9
time step continuity errors : sum local = 3.53757e-09, global = -1.27603e-10, cumulative = 6.39545e-06
GAMG: Solving for p, Initial residual = 0.000212173, Final residual = 8.8988e-07, No Iterations 17
time step continuity errors : sum local = 1.73711e-10, global = 8.18274e-12, cumulative = 6.39546e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000184705, Final residual = 6.06681e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000271696, Final residual = 8.32423e-06, No Iterations 5
ExecutionTime = 48.06 s ClockTime = 48 s
Time = 4.5025
Courant Number mean: 0.113363 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.59181e-05, Final residual = 6.32017e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.92914e-05, Final residual = 5.85882e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000273372, Final residual = 1.80353e-05, No Iterations 9
time step continuity errors : sum local = 3.51736e-09, global = -1.26928e-10, cumulative = 6.39533e-06
GAMG: Solving for p, Initial residual = 0.000211012, Final residual = 8.85091e-07, No Iterations 17
time step continuity errors : sum local = 1.72782e-10, global = 8.14202e-12, cumulative = 6.39534e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000183788, Final residual = 6.0331e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000270497, Final residual = 8.28966e-06, No Iterations 5
ExecutionTime = 48.09 s ClockTime = 48 s
Time = 4.505
Courant Number mean: 0.113364 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.5851e-05, Final residual = 6.30844e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.90971e-05, Final residual = 5.83135e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000269098, Final residual = 1.79314e-05, No Iterations 9
time step continuity errors : sum local = 3.49724e-09, global = -1.2625e-10, cumulative = 6.39522e-06
GAMG: Solving for p, Initial residual = 0.000210039, Final residual = 8.80147e-07, No Iterations 17
time step continuity errors : sum local = 1.71823e-10, global = 8.0985e-12, cumulative = 6.39522e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000182874, Final residual = 6.00016e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000269298, Final residual = 8.25485e-06, No Iterations 5
ExecutionTime = 48.13 s ClockTime = 48 s
Time = 4.5075
Courant Number mean: 0.113365 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.57845e-05, Final residual = 6.29687e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.88996e-05, Final residual = 5.80504e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000264952, Final residual = 1.78253e-05, No Iterations 9
time step continuity errors : sum local = 3.47671e-09, global = -1.25569e-10, cumulative = 6.3951e-06
GAMG: Solving for p, Initial residual = 0.00020898, Final residual = 8.75465e-07, No Iterations 17
time step continuity errors : sum local = 1.70915e-10, global = 8.05883e-12, cumulative = 6.39511e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000181962, Final residual = 5.96726e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000268099, Final residual = 8.22016e-06, No Iterations 5
ExecutionTime = 48.15 s ClockTime = 48 s
Time = 4.51
Courant Number mean: 0.113367 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.57184e-05, Final residual = 6.28533e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.87001e-05, Final residual = 5.77933e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000264793, Final residual = 1.77213e-05, No Iterations 9
time step continuity errors : sum local = 3.45657e-09, global = -1.24892e-10, cumulative = 6.39498e-06
GAMG: Solving for p, Initial residual = 0.00020794, Final residual = 8.70784e-07, No Iterations 17
time step continuity errors : sum local = 1.70007e-10, global = 8.01897e-12, cumulative = 6.39499e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000181053, Final residual = 5.93441e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.0002669, Final residual = 8.18491e-06, No Iterations 5
ExecutionTime = 48.18 s ClockTime = 48 s
Time = 4.5125
Courant Number mean: 0.113368 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.56529e-05, Final residual = 6.27389e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.85042e-05, Final residual = 5.7542e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000262527, Final residual = 1.76162e-05, No Iterations 9
time step continuity errors : sum local = 3.4362e-09, global = -1.24204e-10, cumulative = 6.39486e-06
GAMG: Solving for p, Initial residual = 0.000206887, Final residual = 8.66117e-07, No Iterations 17
time step continuity errors : sum local = 1.69101e-10, global = 7.97947e-12, cumulative = 6.39487e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000180145, Final residual = 5.90158e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000265701, Final residual = 8.14969e-06, No Iterations 5
ExecutionTime = 48.21 s ClockTime = 48 s
Time = 4.515
Courant Number mean: 0.113369 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.55876e-05, Final residual = 6.26249e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.83132e-05, Final residual = 5.72965e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000259597, Final residual = 1.75093e-05, No Iterations 9
time step continuity errors : sum local = 3.41548e-09, global = -1.23489e-10, cumulative = 6.39475e-06
GAMG: Solving for p, Initial residual = 0.00020586, Final residual = 8.61444e-07, No Iterations 17
time step continuity errors : sum local = 1.68194e-10, global = 7.94e-12, cumulative = 6.39476e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000179239, Final residual = 5.86853e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000264503, Final residual = 8.11462e-06, No Iterations 5
ExecutionTime = 48.24 s ClockTime = 49 s
Time = 4.5175
Courant Number mean: 0.113371 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.55225e-05, Final residual = 6.25112e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.81244e-05, Final residual = 5.7054e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000257835, Final residual = 1.74058e-05, No Iterations 9
time step continuity errors : sum local = 3.39544e-09, global = -1.22819e-10, cumulative = 6.39463e-06
GAMG: Solving for p, Initial residual = 0.000204821, Final residual = 8.56775e-07, No Iterations 17
time step continuity errors : sum local = 1.67288e-10, global = 7.9005e-12, cumulative = 6.39464e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000178334, Final residual = 5.83571e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000263305, Final residual = 8.07881e-06, No Iterations 5
ExecutionTime = 48.27 s ClockTime = 49 s
Time = 4.52
Courant Number mean: 0.113372 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.54574e-05, Final residual = 6.2398e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.79376e-05, Final residual = 5.68189e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000256777, Final residual = 1.73021e-05, No Iterations 9
time step continuity errors : sum local = 3.37535e-09, global = -1.22152e-10, cumulative = 6.39452e-06
GAMG: Solving for p, Initial residual = 0.000203803, Final residual = 8.52106e-07, No Iterations 17
time step continuity errors : sum local = 1.66382e-10, global = 7.861e-12, cumulative = 6.39453e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000177432, Final residual = 5.80292e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000262108, Final residual = 8.04309e-06, No Iterations 5
ExecutionTime = 48.3 s ClockTime = 49 s
Time = 4.5225
Courant Number mean: 0.113373 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.53933e-05, Final residual = 6.22857e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.77537e-05, Final residual = 5.65866e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000255739, Final residual = 1.71984e-05, No Iterations 9
time step continuity errors : sum local = 3.35526e-09, global = -1.21485e-10, cumulative = 6.39441e-06
GAMG: Solving for p, Initial residual = 0.000202783, Final residual = 8.47447e-07, No Iterations 17
time step continuity errors : sum local = 1.65478e-10, global = 7.82163e-12, cumulative = 6.39441e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000176531, Final residual = 5.76972e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000260912, Final residual = 8.00792e-06, No Iterations 5
ExecutionTime = 48.32 s ClockTime = 49 s
Time = 4.525
Courant Number mean: 0.113374 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.53291e-05, Final residual = 6.21727e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.75723e-05, Final residual = 5.63581e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000254282, Final residual = 1.70948e-05, No Iterations 9
time step continuity errors : sum local = 3.33519e-09, global = -1.20818e-10, cumulative = 6.39429e-06
GAMG: Solving for p, Initial residual = 0.000201753, Final residual = 8.4279e-07, No Iterations 17
time step continuity errors : sum local = 1.64575e-10, global = 7.78227e-12, cumulative = 6.3943e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000175633, Final residual = 5.73662e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000259716, Final residual = 7.97237e-06, No Iterations 5
ExecutionTime = 48.35 s ClockTime = 49 s
Time = 4.5275
Courant Number mean: 0.113376 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.52648e-05, Final residual = 6.20609e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.73926e-05, Final residual = 5.61344e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000253271, Final residual = 1.69916e-05, No Iterations 9
time step continuity errors : sum local = 3.3152e-09, global = -1.20157e-10, cumulative = 6.39418e-06
GAMG: Solving for p, Initial residual = 0.000200726, Final residual = 8.3814e-07, No Iterations 17
time step continuity errors : sum local = 1.63672e-10, global = 7.743e-12, cumulative = 6.39419e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000174737, Final residual = 5.70338e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000258521, Final residual = 7.93674e-06, No Iterations 5
ExecutionTime = 48.38 s ClockTime = 49 s
Time = 4.53
Courant Number mean: 0.113377 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.52005e-05, Final residual = 6.19484e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.72104e-05, Final residual = 5.59098e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000251347, Final residual = 1.68895e-05, No Iterations 9
time step continuity errors : sum local = 3.29541e-09, global = -1.19514e-10, cumulative = 6.39407e-06
GAMG: Solving for p, Initial residual = 0.000199694, Final residual = 8.33522e-07, No Iterations 17
time step continuity errors : sum local = 1.62775e-10, global = 7.70442e-12, cumulative = 6.39408e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000173842, Final residual = 5.6708e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000257326, Final residual = 7.90158e-06, No Iterations 5
ExecutionTime = 48.4 s ClockTime = 49 s
Time = 4.5325
Courant Number mean: 0.113378 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.51367e-05, Final residual = 6.18399e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.70317e-05, Final residual = 5.56906e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000250728, Final residual = 1.67886e-05, No Iterations 9
time step continuity errors : sum local = 3.27584e-09, global = -1.18872e-10, cumulative = 6.39396e-06
GAMG: Solving for p, Initial residual = 0.00019868, Final residual = 8.28876e-07, No Iterations 17
time step continuity errors : sum local = 1.61873e-10, global = 7.66532e-12, cumulative = 6.39397e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00017295, Final residual = 5.63826e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000256132, Final residual = 7.86609e-06, No Iterations 5
ExecutionTime = 48.43 s ClockTime = 49 s
Time = 4.535
Courant Number mean: 0.113379 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.50734e-05, Final residual = 6.17312e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.6854e-05, Final residual = 5.5474e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000251087, Final residual = 1.66669e-05, No Iterations 9
time step continuity errors : sum local = 3.25223e-09, global = -1.18064e-10, cumulative = 6.39385e-06
GAMG: Solving for p, Initial residual = 0.000198211, Final residual = 8.24116e-07, No Iterations 17
time step continuity errors : sum local = 1.60949e-10, global = 7.62269e-12, cumulative = 6.39386e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000172059, Final residual = 5.60577e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000254939, Final residual = 7.83051e-06, No Iterations 5
ExecutionTime = 48.46 s ClockTime = 49 s
Time = 4.5375
Courant Number mean: 0.113381 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.5011e-05, Final residual = 6.16275e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.66759e-05, Final residual = 5.52601e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000247667, Final residual = 1.657e-05, No Iterations 9
time step continuity errors : sum local = 3.23344e-09, global = -1.17475e-10, cumulative = 6.39374e-06
GAMG: Solving for p, Initial residual = 0.000196926, Final residual = 8.1963e-07, No Iterations 17
time step continuity errors : sum local = 1.60078e-10, global = 7.58579e-12, cumulative = 6.39375e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000171171, Final residual = 5.57362e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000253748, Final residual = 7.79479e-06, No Iterations 5
ExecutionTime = 48.48 s ClockTime = 49 s
Time = 4.54
Courant Number mean: 0.113382 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.4949e-05, Final residual = 6.15218e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.64998e-05, Final residual = 5.50514e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000245192, Final residual = 1.64741e-05, No Iterations 9
time step continuity errors : sum local = 3.21486e-09, global = -1.16861e-10, cumulative = 6.39363e-06
GAMG: Solving for p, Initial residual = 0.000195836, Final residual = 8.15078e-07, No Iterations 17
time step continuity errors : sum local = 1.59194e-10, global = 7.54768e-12, cumulative = 6.39364e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000170284, Final residual = 5.54124e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000252556, Final residual = 7.75872e-06, No Iterations 5
ExecutionTime = 48.51 s ClockTime = 49 s
Time = 4.5425
Courant Number mean: 0.113383 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.48874e-05, Final residual = 6.14182e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.63247e-05, Final residual = 5.48448e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000243082, Final residual = 1.63696e-05, No Iterations 9
time step continuity errors : sum local = 3.19461e-09, global = -1.16204e-10, cumulative = 6.39352e-06
GAMG: Solving for p, Initial residual = 0.000194794, Final residual = 8.10452e-07, No Iterations 17
time step continuity errors : sum local = 1.58295e-10, global = 7.50851e-12, cumulative = 6.39353e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0001694, Final residual = 5.50918e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000251366, Final residual = 7.72255e-06, No Iterations 5
ExecutionTime = 48.54 s ClockTime = 49 s
Time = 4.545
Courant Number mean: 0.113384 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.48261e-05, Final residual = 6.1315e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.61538e-05, Final residual = 5.46453e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000241803, Final residual = 1.62673e-05, No Iterations 9
time step continuity errors : sum local = 3.17476e-09, global = -1.15556e-10, cumulative = 6.39341e-06
GAMG: Solving for p, Initial residual = 0.000193805, Final residual = 8.05854e-07, No Iterations 17
time step continuity errors : sum local = 1.57402e-10, global = 7.46937e-12, cumulative = 6.39342e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000168517, Final residual = 5.47691e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000250176, Final residual = 7.68634e-06, No Iterations 5
ExecutionTime = 48.56 s ClockTime = 49 s
Time = 4.5475
Courant Number mean: 0.113386 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.47644e-05, Final residual = 6.12125e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.59855e-05, Final residual = 5.4447e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000240533, Final residual = 1.63205e-05, No Iterations 9
time step continuity errors : sum local = 3.18527e-09, global = -1.15133e-10, cumulative = 6.3933e-06
GAMG: Solving for p, Initial residual = 0.000192906, Final residual = 8.01143e-07, No Iterations 17
time step continuity errors : sum local = 1.56487e-10, global = 7.42976e-12, cumulative = 6.39331e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000167637, Final residual = 5.4447e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000248987, Final residual = 7.65026e-06, No Iterations 5
ExecutionTime = 48.59 s ClockTime = 49 s
Time = 4.55
Courant Number mean: 0.113387 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.47032e-05, Final residual = 6.11114e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.58185e-05, Final residual = 5.42509e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000239329, Final residual = 1.62128e-05, No Iterations 9
time step continuity errors : sum local = 3.16436e-09, global = -1.14484e-10, cumulative = 6.3932e-06
GAMG: Solving for p, Initial residual = 0.000191891, Final residual = 7.96521e-07, No Iterations 17
time step continuity errors : sum local = 1.55589e-10, global = 7.39051e-12, cumulative = 6.3932e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000166759, Final residual = 5.41236e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000247798, Final residual = 7.61464e-06, No Iterations 5
ExecutionTime = 48.62 s ClockTime = 49 s
Time = 4.5525
Courant Number mean: 0.113388 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.46423e-05, Final residual = 6.10093e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.56528e-05, Final residual = 5.40578e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000238178, Final residual = 1.61066e-05, No Iterations 9
time step continuity errors : sum local = 3.14377e-09, global = -1.13853e-10, cumulative = 6.39309e-06
GAMG: Solving for p, Initial residual = 0.000190905, Final residual = 7.91966e-07, No Iterations 17
time step continuity errors : sum local = 1.54704e-10, global = 7.35172e-12, cumulative = 6.3931e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000165883, Final residual = 5.37998e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000246611, Final residual = 7.57878e-06, No Iterations 5
ExecutionTime = 48.64 s ClockTime = 49 s
Time = 4.555
Courant Number mean: 0.113389 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.45816e-05, Final residual = 6.09073e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.54879e-05, Final residual = 5.38651e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000237016, Final residual = 1.6e-05, No Iterations 9
time step continuity errors : sum local = 3.12309e-09, global = -1.13223e-10, cumulative = 6.39299e-06
GAMG: Solving for p, Initial residual = 0.000189934, Final residual = 7.87428e-07, No Iterations 17
time step continuity errors : sum local = 1.53823e-10, global = 7.31307e-12, cumulative = 6.39299e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00016501, Final residual = 5.3482e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000245424, Final residual = 7.54282e-06, No Iterations 5
ExecutionTime = 48.67 s ClockTime = 49 s
Time = 4.5575
Courant Number mean: 0.11339 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.45208e-05, Final residual = 6.08051e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.5324e-05, Final residual = 5.36764e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000235976, Final residual = 1.58931e-05, No Iterations 9
time step continuity errors : sum local = 3.10235e-09, global = -1.12597e-10, cumulative = 6.39288e-06
GAMG: Solving for p, Initial residual = 0.00018897, Final residual = 7.82904e-07, No Iterations 17
time step continuity errors : sum local = 1.52944e-10, global = 7.27459e-12, cumulative = 6.39289e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000164138, Final residual = 5.31619e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000244239, Final residual = 7.50658e-06, No Iterations 5
ExecutionTime = 48.71 s ClockTime = 49 s
Time = 4.56
Courant Number mean: 0.113392 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.44603e-05, Final residual = 6.07031e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.51609e-05, Final residual = 5.34898e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000235511, Final residual = 1.57854e-05, No Iterations 9
time step continuity errors : sum local = 3.08145e-09, global = -1.11969e-10, cumulative = 6.39278e-06
GAMG: Solving for p, Initial residual = 0.00018801, Final residual = 7.78396e-07, No Iterations 17
time step continuity errors : sum local = 1.52069e-10, global = 7.23629e-12, cumulative = 6.39278e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000163269, Final residual = 5.28441e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000243055, Final residual = 7.47043e-06, No Iterations 5
ExecutionTime = 48.75 s ClockTime = 49 s
Time = 4.5625
Courant Number mean: 0.113393 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.43995e-05, Final residual = 6.06012e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.4999e-05, Final residual = 5.33037e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000235094, Final residual = 1.56771e-05, No Iterations 9
time step continuity errors : sum local = 3.06043e-09, global = -1.11341e-10, cumulative = 6.39267e-06
GAMG: Solving for p, Initial residual = 0.000187054, Final residual = 7.73904e-07, No Iterations 17
time step continuity errors : sum local = 1.51196e-10, global = 7.19811e-12, cumulative = 6.39268e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000162401, Final residual = 5.25259e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000241873, Final residual = 7.43437e-06, No Iterations 5
ExecutionTime = 48.78 s ClockTime = 49 s
Time = 4.565
Courant Number mean: 0.113394 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.43389e-05, Final residual = 6.05022e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.48373e-05, Final residual = 5.31194e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000234104, Final residual = 1.55689e-05, No Iterations 9
time step continuity errors : sum local = 3.03944e-09, global = -1.10725e-10, cumulative = 6.39257e-06
GAMG: Solving for p, Initial residual = 0.000186093, Final residual = 7.69425e-07, No Iterations 17
time step continuity errors : sum local = 1.50326e-10, global = 7.16e-12, cumulative = 6.39257e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000161535, Final residual = 5.22084e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000240691, Final residual = 7.39834e-06, No Iterations 5
ExecutionTime = 48.81 s ClockTime = 49 s
Time = 4.5675
Courant Number mean: 0.113395 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.42793e-05, Final residual = 6.0405e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.46754e-05, Final residual = 5.29353e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000236967, Final residual = 1.54616e-05, No Iterations 9
time step continuity errors : sum local = 3.01861e-09, global = -1.10132e-10, cumulative = 6.39246e-06
GAMG: Solving for p, Initial residual = 0.000185119, Final residual = 7.6496e-07, No Iterations 17
time step continuity errors : sum local = 1.49458e-10, global = 7.12203e-12, cumulative = 6.39247e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000160672, Final residual = 5.18894e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000239511, Final residual = 7.36178e-06, No Iterations 5
ExecutionTime = 48.83 s ClockTime = 49 s
Time = 4.57
Courant Number mean: 0.113396 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.42199e-05, Final residual = 6.03082e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.45192e-05, Final residual = 5.27529e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000236942, Final residual = 1.53528e-05, No Iterations 9
time step continuity errors : sum local = 2.99747e-09, global = -1.09534e-10, cumulative = 6.39236e-06
GAMG: Solving for p, Initial residual = 0.000184185, Final residual = 7.60509e-07, No Iterations 17
time step continuity errors : sum local = 1.48593e-10, global = 7.08398e-12, cumulative = 6.39237e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000159811, Final residual = 5.15699e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000238332, Final residual = 7.32528e-06, No Iterations 5
ExecutionTime = 48.86 s ClockTime = 49 s
Time = 4.5725
Courant Number mean: 0.113397 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.41613e-05, Final residual = 6.0213e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.43629e-05, Final residual = 5.25709e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00023639, Final residual = 1.52399e-05, No Iterations 9
time step continuity errors : sum local = 2.97554e-09, global = -1.08897e-10, cumulative = 6.39226e-06
GAMG: Solving for p, Initial residual = 0.000183208, Final residual = 7.56111e-07, No Iterations 17
time step continuity errors : sum local = 1.47737e-10, global = 7.04696e-12, cumulative = 6.39227e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000158953, Final residual = 5.12597e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000237154, Final residual = 7.28855e-06, No Iterations 5
ExecutionTime = 48.88 s ClockTime = 49 s
Time = 4.575
Courant Number mean: 0.113399 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.41031e-05, Final residual = 6.01181e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.42101e-05, Final residual = 5.23943e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000235324, Final residual = 1.51292e-05, No Iterations 9
time step continuity errors : sum local = 2.95403e-09, global = -1.083e-10, cumulative = 6.39216e-06
GAMG: Solving for p, Initial residual = 0.000182259, Final residual = 7.51695e-07, No Iterations 17
time step continuity errors : sum local = 1.46878e-10, global = 7.00916e-12, cumulative = 6.39217e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000158098, Final residual = 5.09463e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000235978, Final residual = 7.25222e-06, No Iterations 5
ExecutionTime = 48.92 s ClockTime = 49 s
Time = 4.5775
Courant Number mean: 0.1134 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.40451e-05, Final residual = 6.00236e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.40538e-05, Final residual = 5.22149e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000234484, Final residual = 1.50161e-05, No Iterations 9
time step continuity errors : sum local = 2.93203e-09, global = -1.07688e-10, cumulative = 6.39206e-06
GAMG: Solving for p, Initial residual = 0.000181308, Final residual = 7.47305e-07, No Iterations 17
time step continuity errors : sum local = 1.46024e-10, global = 6.97181e-12, cumulative = 6.39207e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000157244, Final residual = 5.0632e-06, No Iterations 4
smoothSolver: Solving for k, Initial residual = 0.000234804, Final residual = 7.21606e-06, No Iterations 5
ExecutionTime = 48.95 s ClockTime = 49 s
Time = 4.58
Courant Number mean: 0.113401 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.39873e-05, Final residual = 5.99294e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.38975e-05, Final residual = 5.20367e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000233562, Final residual = 1.49018e-05, No Iterations 9
time step continuity errors : sum local = 2.90983e-09, global = -1.07077e-10, cumulative = 6.39196e-06
GAMG: Solving for p, Initial residual = 0.000180358, Final residual = 7.42935e-07, No Iterations 17
time step continuity errors : sum local = 1.45174e-10, global = 6.93463e-12, cumulative = 6.39197e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000156393, Final residual = 9.9711e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000233657, Final residual = 7.18173e-06, No Iterations 5
ExecutionTime = 48.98 s ClockTime = 49 s
Time = 4.5825
Courant Number mean: 0.113402 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.39318e-05, Final residual = 5.9839e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.3758e-05, Final residual = 5.1916e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000234099, Final residual = 1.47694e-05, No Iterations 9
time step continuity errors : sum local = 2.88407e-09, global = -1.06408e-10, cumulative = 6.39186e-06
GAMG: Solving for p, Initial residual = 0.000179637, Final residual = 7.39861e-07, No Iterations 17
time step continuity errors : sum local = 1.44578e-10, global = 6.90128e-12, cumulative = 6.39187e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000155728, Final residual = 9.93856e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000232559, Final residual = 7.14965e-06, No Iterations 5
ExecutionTime = 49 s ClockTime = 49 s
Time = 4.585
Courant Number mean: 0.113403 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.38758e-05, Final residual = 5.97449e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.3603e-05, Final residual = 5.17491e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000233262, Final residual = 1.46728e-05, No Iterations 9
time step continuity errors : sum local = 2.86533e-09, global = -1.06018e-10, cumulative = 6.39176e-06
GAMG: Solving for p, Initial residual = 0.000178898, Final residual = 7.35332e-07, No Iterations 17
time step continuity errors : sum local = 1.43698e-10, global = 6.86263e-12, cumulative = 6.39177e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000155052, Final residual = 9.9038e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000231461, Final residual = 7.11725e-06, No Iterations 5
ExecutionTime = 49.03 s ClockTime = 49 s
Time = 4.5875
Courant Number mean: 0.113404 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.38209e-05, Final residual = 5.96582e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.34504e-05, Final residual = 5.15837e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000232148, Final residual = 1.45487e-05, No Iterations 9
time step continuity errors : sum local = 2.84121e-09, global = -1.05345e-10, cumulative = 6.39166e-06
GAMG: Solving for p, Initial residual = 0.000177942, Final residual = 7.30735e-07, No Iterations 17
time step continuity errors : sum local = 1.42805e-10, global = 6.82309e-12, cumulative = 6.39167e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000154369, Final residual = 9.86689e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00023036, Final residual = 7.08493e-06, No Iterations 5
ExecutionTime = 49.05 s ClockTime = 49 s
Time = 4.59
Courant Number mean: 0.113405 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.37654e-05, Final residual = 5.95706e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.32987e-05, Final residual = 5.14176e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000230985, Final residual = 1.44316e-05, No Iterations 9
time step continuity errors : sum local = 2.81848e-09, global = -1.04749e-10, cumulative = 6.39156e-06
GAMG: Solving for p, Initial residual = 0.000176976, Final residual = 7.26006e-07, No Iterations 17
time step continuity errors : sum local = 1.41886e-10, global = 6.78316e-12, cumulative = 6.39157e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000153682, Final residual = 9.82838e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00022926, Final residual = 7.05208e-06, No Iterations 5
ExecutionTime = 49.08 s ClockTime = 49 s
Time = 4.5925
Courant Number mean: 0.113407 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.37103e-05, Final residual = 5.94871e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.31465e-05, Final residual = 5.12499e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000229659, Final residual = 1.4313e-05, No Iterations 9
time step continuity errors : sum local = 2.79544e-09, global = -1.04137e-10, cumulative = 6.39147e-06
GAMG: Solving for p, Initial residual = 0.000176011, Final residual = 7.21414e-07, No Iterations 17
time step continuity errors : sum local = 1.40994e-10, global = 6.74467e-12, cumulative = 6.39147e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000152988, Final residual = 9.78848e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000228158, Final residual = 7.01906e-06, No Iterations 5
ExecutionTime = 49.11 s ClockTime = 49 s
Time = 4.595
Courant Number mean: 0.113408 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.36557e-05, Final residual = 5.9405e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.29935e-05, Final residual = 5.10842e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00022948, Final residual = 1.41971e-05, No Iterations 9
time step continuity errors : sum local = 2.77292e-09, global = -1.03543e-10, cumulative = 6.39137e-06
GAMG: Solving for p, Initial residual = 0.000175076, Final residual = 7.16838e-07, No Iterations 17
time step continuity errors : sum local = 1.40104e-10, global = 6.70639e-12, cumulative = 6.39138e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000152288, Final residual = 9.74725e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000227055, Final residual = 6.98601e-06, No Iterations 5
ExecutionTime = 49.14 s ClockTime = 49 s
Time = 4.5975
Courant Number mean: 0.113409 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.36018e-05, Final residual = 5.93243e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.28415e-05, Final residual = 5.09189e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00022841, Final residual = 1.40834e-05, No Iterations 9
time step continuity errors : sum local = 2.75083e-09, global = -1.0295e-10, cumulative = 6.39127e-06
GAMG: Solving for p, Initial residual = 0.000174135, Final residual = 7.12295e-07, No Iterations 17
time step continuity errors : sum local = 1.39221e-10, global = 6.66836e-12, cumulative = 6.39128e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000151585, Final residual = 9.70484e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000225952, Final residual = 6.95276e-06, No Iterations 5
ExecutionTime = 49.16 s ClockTime = 49 s
Time = 4.6
Courant Number mean: 0.11341 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.35476e-05, Final residual = 5.92438e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.269e-05, Final residual = 5.07579e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000227039, Final residual = 1.39724e-05, No Iterations 9
time step continuity errors : sum local = 2.72926e-09, global = -1.02365e-10, cumulative = 6.39118e-06
GAMG: Solving for p, Initial residual = 0.000173188, Final residual = 7.07787e-07, No Iterations 17
time step continuity errors : sum local = 1.38345e-10, global = 6.63063e-12, cumulative = 6.39118e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000150877, Final residual = 9.66131e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000224848, Final residual = 6.91929e-06, No Iterations 5
ExecutionTime = 49.23 s ClockTime = 50 s
Time = 4.6025
Courant Number mean: 0.113411 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.34936e-05, Final residual = 5.91644e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.25393e-05, Final residual = 5.06065e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000225738, Final residual = 1.38637e-05, No Iterations 9
time step continuity errors : sum local = 2.70815e-09, global = -1.01783e-10, cumulative = 6.39108e-06
GAMG: Solving for p, Initial residual = 0.00017225, Final residual = 7.03307e-07, No Iterations 17
time step continuity errors : sum local = 1.37474e-10, global = 6.59309e-12, cumulative = 6.39109e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000150167, Final residual = 9.61758e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000223744, Final residual = 6.88537e-06, No Iterations 5
ExecutionTime = 49.25 s ClockTime = 50 s
Time = 4.605
Courant Number mean: 0.113412 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.34399e-05, Final residual = 5.90853e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.23889e-05, Final residual = 5.04626e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000224473, Final residual = 1.37574e-05, No Iterations 9
time step continuity errors : sum local = 2.68749e-09, global = -1.01206e-10, cumulative = 6.39099e-06
GAMG: Solving for p, Initial residual = 0.000171315, Final residual = 6.9885e-07, No Iterations 17
time step continuity errors : sum local = 1.36608e-10, global = 6.55576e-12, cumulative = 6.39099e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000149455, Final residual = 9.57318e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000222639, Final residual = 6.85165e-06, No Iterations 5
ExecutionTime = 49.28 s ClockTime = 50 s
Time = 4.6075
Courant Number mean: 0.113413 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.33863e-05, Final residual = 5.90058e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.22386e-05, Final residual = 5.03219e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000223228, Final residual = 1.36533e-05, No Iterations 9
time step continuity errors : sum local = 2.66728e-09, global = -1.00634e-10, cumulative = 6.39089e-06
GAMG: Solving for p, Initial residual = 0.000170387, Final residual = 6.94411e-07, No Iterations 17
time step continuity errors : sum local = 1.35744e-10, global = 6.51858e-12, cumulative = 6.3909e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000148741, Final residual = 9.52762e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000221535, Final residual = 6.81727e-06, No Iterations 5
ExecutionTime = 49.3 s ClockTime = 50 s
Time = 4.61
Courant Number mean: 0.113414 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.33326e-05, Final residual = 5.89255e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.20909e-05, Final residual = 5.01819e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000222157, Final residual = 1.34965e-05, No Iterations 9
time step continuity errors : sum local = 2.63675e-09, global = -9.92424e-11, cumulative = 6.3908e-06
GAMG: Solving for p, Initial residual = 0.000169534, Final residual = 6.91379e-07, No Iterations 17
time step continuity errors : sum local = 1.35157e-10, global = 6.49973e-12, cumulative = 6.39081e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000148025, Final residual = 9.48209e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00022043, Final residual = 6.78334e-06, No Iterations 5
ExecutionTime = 49.33 s ClockTime = 50 s
Time = 4.6125
Courant Number mean: 0.113415 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.32788e-05, Final residual = 5.8844e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.19462e-05, Final residual = 5.00472e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000221056, Final residual = 1.33949e-05, No Iterations 9
time step continuity errors : sum local = 2.61701e-09, global = -9.87428e-11, cumulative = 6.39071e-06
GAMG: Solving for p, Initial residual = 0.000168669, Final residual = 6.87124e-07, No Iterations 17
time step continuity errors : sum local = 1.3433e-10, global = 6.46382e-12, cumulative = 6.39071e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000147308, Final residual = 9.43654e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000219323, Final residual = 6.74899e-06, No Iterations 5
ExecutionTime = 49.36 s ClockTime = 50 s
Time = 4.615
Courant Number mean: 0.113416 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.32254e-05, Final residual = 5.87638e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.18016e-05, Final residual = 4.99132e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.0002198, Final residual = 1.3285e-05, No Iterations 9
time step continuity errors : sum local = 2.59564e-09, global = -9.81663e-11, cumulative = 6.39062e-06
GAMG: Solving for p, Initial residual = 0.000167729, Final residual = 6.82639e-07, No Iterations 17
time step continuity errors : sum local = 1.33457e-10, global = 6.42549e-12, cumulative = 6.39062e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000146589, Final residual = 9.3901e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000218218, Final residual = 6.71488e-06, No Iterations 5
ExecutionTime = 49.38 s ClockTime = 50 s
Time = 4.6175
Courant Number mean: 0.113417 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.3172e-05, Final residual = 5.86826e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.16579e-05, Final residual = 4.97802e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000218602, Final residual = 1.31746e-05, No Iterations 9
time step continuity errors : sum local = 2.57419e-09, global = -9.75893e-11, cumulative = 6.39053e-06
GAMG: Solving for p, Initial residual = 0.000166792, Final residual = 6.78343e-07, No Iterations 17
time step continuity errors : sum local = 1.32622e-10, global = 6.38972e-12, cumulative = 6.39053e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00014587, Final residual = 9.34276e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000217112, Final residual = 6.68e-06, No Iterations 5
ExecutionTime = 49.41 s ClockTime = 50 s
Time = 4.62
Courant Number mean: 0.113418 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.31187e-05, Final residual = 5.86007e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.15141e-05, Final residual = 4.9648e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000217389, Final residual = 1.30809e-05, No Iterations 9
time step continuity errors : sum local = 2.55598e-09, global = -9.70802e-11, cumulative = 6.39043e-06
GAMG: Solving for p, Initial residual = 0.000165865, Final residual = 6.73859e-07, No Iterations 17
time step continuity errors : sum local = 1.3175e-10, global = 6.35114e-12, cumulative = 6.39044e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000145145, Final residual = 9.29547e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000216008, Final residual = 6.64614e-06, No Iterations 5
ExecutionTime = 49.44 s ClockTime = 50 s
Time = 4.6225
Courant Number mean: 0.113419 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.30651e-05, Final residual = 5.85178e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.13708e-05, Final residual = 4.95168e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000216255, Final residual = 1.29743e-05, No Iterations 9
time step continuity errors : sum local = 2.53526e-09, global = -9.6504e-11, cumulative = 6.39034e-06
GAMG: Solving for p, Initial residual = 0.000164971, Final residual = 6.69593e-07, No Iterations 17
time step continuity errors : sum local = 1.3092e-10, global = 6.31549e-12, cumulative = 6.39035e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00014442, Final residual = 9.24801e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000214904, Final residual = 6.61175e-06, No Iterations 5
ExecutionTime = 49.46 s ClockTime = 50 s
Time = 4.625
Courant Number mean: 0.11342 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.30119e-05, Final residual = 5.84371e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.12276e-05, Final residual = 4.93872e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000215123, Final residual = 1.28704e-05, No Iterations 9
time step continuity errors : sum local = 2.51506e-09, global = -9.59412e-11, cumulative = 6.39025e-06
GAMG: Solving for p, Initial residual = 0.000164083, Final residual = 6.65356e-07, No Iterations 17
time step continuity errors : sum local = 1.30096e-10, global = 6.28011e-12, cumulative = 6.39026e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000143696, Final residual = 9.20073e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000213801, Final residual = 6.57671e-06, No Iterations 5
ExecutionTime = 49.49 s ClockTime = 50 s
Time = 4.6275
Courant Number mean: 0.113421 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.29592e-05, Final residual = 5.83587e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.10843e-05, Final residual = 4.92611e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000213949, Final residual = 1.27678e-05, No Iterations 9
time step continuity errors : sum local = 2.4951e-09, global = -9.53821e-11, cumulative = 6.39017e-06
GAMG: Solving for p, Initial residual = 0.000163197, Final residual = 6.61132e-07, No Iterations 17
time step continuity errors : sum local = 1.29274e-10, global = 6.24484e-12, cumulative = 6.39017e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000142971, Final residual = 9.15281e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000212698, Final residual = 6.54214e-06, No Iterations 5
ExecutionTime = 49.52 s ClockTime = 50 s
Time = 4.63
Courant Number mean: 0.113422 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.29064e-05, Final residual = 5.82814e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.09422e-05, Final residual = 4.91373e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000212846, Final residual = 1.26667e-05, No Iterations 9
time step continuity errors : sum local = 2.47545e-09, global = -9.48293e-11, cumulative = 6.39008e-06
GAMG: Solving for p, Initial residual = 0.000162311, Final residual = 6.56932e-07, No Iterations 17
time step continuity errors : sum local = 1.28457e-10, global = 6.20975e-12, cumulative = 6.39008e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000142247, Final residual = 9.10456e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000211596, Final residual = 6.50743e-06, No Iterations 5
ExecutionTime = 49.54 s ClockTime = 50 s
Time = 4.6325
Courant Number mean: 0.113423 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.28536e-05, Final residual = 5.8204e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.08024e-05, Final residual = 4.90155e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000211712, Final residual = 1.25671e-05, No Iterations 9
time step continuity errors : sum local = 2.45608e-09, global = -9.42832e-11, cumulative = 6.38999e-06
GAMG: Solving for p, Initial residual = 0.000161426, Final residual = 6.52748e-07, No Iterations 17
time step continuity errors : sum local = 1.27643e-10, global = 6.17486e-12, cumulative = 6.39e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000141523, Final residual = 9.05568e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000210494, Final residual = 6.47182e-06, No Iterations 5
ExecutionTime = 49.57 s ClockTime = 50 s
Time = 4.635
Courant Number mean: 0.113424 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.28011e-05, Final residual = 5.8127e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.06641e-05, Final residual = 4.88938e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000210573, Final residual = 1.24684e-05, No Iterations 9
time step continuity errors : sum local = 2.43688e-09, global = -9.37443e-11, cumulative = 6.3899e-06
GAMG: Solving for p, Initial residual = 0.000160545, Final residual = 6.48579e-07, No Iterations 17
time step continuity errors : sum local = 1.26832e-10, global = 6.14015e-12, cumulative = 6.38991e-06
smoothSolver: Solving for epsilon, Initial residual = 0.0001408, Final residual = 9.00693e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000209392, Final residual = 6.43675e-06, No Iterations 5
ExecutionTime = 49.6 s ClockTime = 50 s
Time = 4.6375
Courant Number mean: 0.113425 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.27486e-05, Final residual = 5.80497e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.05264e-05, Final residual = 4.87736e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00020944, Final residual = 1.23706e-05, No Iterations 9
time step continuity errors : sum local = 2.41788e-09, global = -9.32123e-11, cumulative = 6.38981e-06
GAMG: Solving for p, Initial residual = 0.000159669, Final residual = 6.44429e-07, No Iterations 17
time step continuity errors : sum local = 1.26025e-10, global = 6.10563e-12, cumulative = 6.38982e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000140076, Final residual = 8.95781e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000208292, Final residual = 6.40179e-06, No Iterations 5
ExecutionTime = 49.62 s ClockTime = 50 s
Time = 4.64
Courant Number mean: 0.113426 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.26964e-05, Final residual = 5.79744e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.0389e-05, Final residual = 4.86536e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000208361, Final residual = 1.22736e-05, No Iterations 9
time step continuity errors : sum local = 2.399e-09, global = -9.26867e-11, cumulative = 6.38973e-06
GAMG: Solving for p, Initial residual = 0.000158797, Final residual = 6.40306e-07, No Iterations 17
time step continuity errors : sum local = 1.25222e-10, global = 6.0713e-12, cumulative = 6.38973e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000139352, Final residual = 8.90841e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000207193, Final residual = 6.36704e-06, No Iterations 5
ExecutionTime = 49.65 s ClockTime = 50 s
Time = 4.6425
Courant Number mean: 0.113427 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.26455e-05, Final residual = 5.79015e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.02521e-05, Final residual = 4.85351e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00020789, Final residual = 1.22352e-05, No Iterations 9
time step continuity errors : sum local = 2.39159e-09, global = -9.2133e-11, cumulative = 6.38964e-06
GAMG: Solving for p, Initial residual = 0.000157979, Final residual = 6.36154e-07, No Iterations 17
time step continuity errors : sum local = 1.24414e-10, global = 6.03699e-12, cumulative = 6.38965e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000138629, Final residual = 8.85926e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000206095, Final residual = 6.33172e-06, No Iterations 5
ExecutionTime = 49.67 s ClockTime = 50 s
Time = 4.645
Courant Number mean: 0.113428 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.25948e-05, Final residual = 5.78308e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 4.01149e-05, Final residual = 4.8416e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000206136, Final residual = 1.21367e-05, No Iterations 9
time step continuity errors : sum local = 2.37242e-09, global = -9.16204e-11, cumulative = 6.38956e-06
GAMG: Solving for p, Initial residual = 0.0001571, Final residual = 6.32049e-07, No Iterations 17
time step continuity errors : sum local = 1.23615e-10, global = 6.00292e-12, cumulative = 6.38956e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000137906, Final residual = 8.80994e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000204997, Final residual = 6.29642e-06, No Iterations 5
ExecutionTime = 49.7 s ClockTime = 50 s
Time = 4.6475
Courant Number mean: 0.113429 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.25442e-05, Final residual = 5.77609e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.99803e-05, Final residual = 4.8298e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000204877, Final residual = 1.20394e-05, No Iterations 9
time step continuity errors : sum local = 2.35351e-09, global = -9.11222e-11, cumulative = 6.38947e-06
GAMG: Solving for p, Initial residual = 0.000156239, Final residual = 6.27982e-07, No Iterations 17
time step continuity errors : sum local = 1.22824e-10, global = 5.96917e-12, cumulative = 6.38948e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000137183, Final residual = 8.76058e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000203901, Final residual = 6.26109e-06, No Iterations 5
ExecutionTime = 49.73 s ClockTime = 50 s
Time = 4.65
Courant Number mean: 0.11343 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.24937e-05, Final residual = 5.76916e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.98459e-05, Final residual = 4.81813e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000203772, Final residual = 1.19431e-05, No Iterations 9
time step continuity errors : sum local = 2.33476e-09, global = -9.06371e-11, cumulative = 6.38939e-06
GAMG: Solving for p, Initial residual = 0.000155387, Final residual = 6.23937e-07, No Iterations 17
time step continuity errors : sum local = 1.22036e-10, global = 5.93561e-12, cumulative = 6.38939e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000136461, Final residual = 8.71093e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000202805, Final residual = 6.22637e-06, No Iterations 5
ExecutionTime = 49.77 s ClockTime = 50 s
Time = 4.6525
Courant Number mean: 0.113431 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.24437e-05, Final residual = 5.76231e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.97117e-05, Final residual = 4.80633e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000202748, Final residual = 1.1847e-05, No Iterations 9
time step continuity errors : sum local = 2.31605e-09, global = -9.01585e-11, cumulative = 6.3893e-06
GAMG: Solving for p, Initial residual = 0.000154534, Final residual = 6.19911e-07, No Iterations 17
time step continuity errors : sum local = 1.21252e-10, global = 5.90226e-12, cumulative = 6.38931e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00013574, Final residual = 8.66117e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000201711, Final residual = 6.19151e-06, No Iterations 5
ExecutionTime = 49.79 s ClockTime = 50 s
Time = 4.655
Courant Number mean: 0.113432 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.23937e-05, Final residual = 5.75544e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.95776e-05, Final residual = 4.79471e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000201926, Final residual = 1.17516e-05, No Iterations 9
time step continuity errors : sum local = 2.29749e-09, global = -8.96886e-11, cumulative = 6.38922e-06
GAMG: Solving for p, Initial residual = 0.000153687, Final residual = 6.15908e-07, No Iterations 17
time step continuity errors : sum local = 1.20473e-10, global = 5.8691e-12, cumulative = 6.38922e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000135019, Final residual = 8.61097e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000200619, Final residual = 6.15622e-06, No Iterations 5
ExecutionTime = 49.82 s ClockTime = 50 s
Time = 4.6575
Courant Number mean: 0.113433 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.23436e-05, Final residual = 5.74853e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.94429e-05, Final residual = 4.78305e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000200903, Final residual = 1.16571e-05, No Iterations 9
time step continuity errors : sum local = 2.27909e-09, global = -8.92306e-11, cumulative = 6.38914e-06
GAMG: Solving for p, Initial residual = 0.000152835, Final residual = 6.11916e-07, No Iterations 17
time step continuity errors : sum local = 1.19695e-10, global = 5.83607e-12, cumulative = 6.38914e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000134299, Final residual = 8.56027e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000199528, Final residual = 6.12038e-06, No Iterations 5
ExecutionTime = 49.85 s ClockTime = 50 s
Time = 4.66
Courant Number mean: 0.113434 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.22933e-05, Final residual = 5.74165e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.93083e-05, Final residual = 4.77131e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000199747, Final residual = 1.15629e-05, No Iterations 9
time step continuity errors : sum local = 2.26075e-09, global = -8.87818e-11, cumulative = 6.38905e-06
GAMG: Solving for p, Initial residual = 0.000151982, Final residual = 6.0794e-07, No Iterations 17
time step continuity errors : sum local = 1.18921e-10, global = 5.80327e-12, cumulative = 6.38906e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00013358, Final residual = 8.51025e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000198437, Final residual = 6.08544e-06, No Iterations 5
ExecutionTime = 49.88 s ClockTime = 50 s
Time = 4.6625
Courant Number mean: 0.113435 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.22429e-05, Final residual = 5.73474e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.91747e-05, Final residual = 4.75961e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000198495, Final residual = 1.14687e-05, No Iterations 9
time step continuity errors : sum local = 2.24241e-09, global = -8.83424e-11, cumulative = 6.38897e-06
GAMG: Solving for p, Initial residual = 0.000151135, Final residual = 6.03991e-07, No Iterations 17
time step continuity errors : sum local = 1.18151e-10, global = 5.77069e-12, cumulative = 6.38898e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000132861, Final residual = 8.45988e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000197348, Final residual = 6.05013e-06, No Iterations 5
ExecutionTime = 49.9 s ClockTime = 50 s
Time = 4.665
Courant Number mean: 0.113436 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.21924e-05, Final residual = 5.72771e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.90413e-05, Final residual = 4.74782e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000197372, Final residual = 1.13749e-05, No Iterations 9
time step continuity errors : sum local = 2.22415e-09, global = -8.79099e-11, cumulative = 6.38889e-06
GAMG: Solving for p, Initial residual = 0.000150284, Final residual = 6.00067e-07, No Iterations 17
time step continuity errors : sum local = 1.17387e-10, global = 5.73839e-12, cumulative = 6.38889e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000132142, Final residual = 8.40972e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000196261, Final residual = 6.0152e-06, No Iterations 5
ExecutionTime = 49.93 s ClockTime = 50 s
Time = 4.6675
Courant Number mean: 0.113437 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.21415e-05, Final residual = 5.72054e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.89078e-05, Final residual = 4.73606e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000196375, Final residual = 1.12816e-05, No Iterations 9
time step continuity errors : sum local = 2.20599e-09, global = -8.74881e-11, cumulative = 6.38881e-06
GAMG: Solving for p, Initial residual = 0.00014944, Final residual = 5.96163e-07, No Iterations 17
time step continuity errors : sum local = 1.16626e-10, global = 5.70629e-12, cumulative = 6.38881e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000131424, Final residual = 8.3595e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000195176, Final residual = 5.98019e-06, No Iterations 5
ExecutionTime = 49.96 s ClockTime = 50 s
Time = 4.67
Courant Number mean: 0.113438 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.20905e-05, Final residual = 5.71323e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.87741e-05, Final residual = 4.72423e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000195282, Final residual = 1.11888e-05, No Iterations 9
time step continuity errors : sum local = 2.18791e-09, global = -8.70768e-11, cumulative = 6.38872e-06
GAMG: Solving for p, Initial residual = 0.000148608, Final residual = 5.92279e-07, No Iterations 17
time step continuity errors : sum local = 1.1587e-10, global = 5.67441e-12, cumulative = 6.38873e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000130706, Final residual = 8.30859e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000194091, Final residual = 5.94523e-06, No Iterations 5
ExecutionTime = 49.99 s ClockTime = 50 s
Time = 4.6725
Courant Number mean: 0.113439 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.204e-05, Final residual = 5.70576e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.86413e-05, Final residual = 4.71261e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000194207, Final residual = 1.10964e-05, No Iterations 9
time step continuity errors : sum local = 2.16991e-09, global = -8.66754e-11, cumulative = 6.38864e-06
GAMG: Solving for p, Initial residual = 0.000147783, Final residual = 5.88418e-07, No Iterations 17
time step continuity errors : sum local = 1.15117e-10, global = 5.64277e-12, cumulative = 6.38865e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000129989, Final residual = 8.25842e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000193008, Final residual = 5.90995e-06, No Iterations 5
ExecutionTime = 50.02 s ClockTime = 50 s
Time = 4.675
Courant Number mean: 0.11344 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.19897e-05, Final residual = 5.6981e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.85087e-05, Final residual = 4.70106e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000193229, Final residual = 1.10048e-05, No Iterations 9
time step continuity errors : sum local = 2.15207e-09, global = -8.62866e-11, cumulative = 6.38856e-06
GAMG: Solving for p, Initial residual = 0.000146965, Final residual = 5.84585e-07, No Iterations 17
time step continuity errors : sum local = 1.1437e-10, global = 5.61139e-12, cumulative = 6.38857e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000129273, Final residual = 8.20686e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000191926, Final residual = 5.87429e-06, No Iterations 5
ExecutionTime = 50.04 s ClockTime = 50 s
Time = 4.6775
Courant Number mean: 0.11344 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.19391e-05, Final residual = 5.69032e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.83777e-05, Final residual = 4.68949e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000192164, Final residual = 1.09133e-05, No Iterations 9
time step continuity errors : sum local = 2.13425e-09, global = -8.5905e-11, cumulative = 6.38848e-06
GAMG: Solving for p, Initial residual = 0.000146155, Final residual = 5.80765e-07, No Iterations 17
time step continuity errors : sum local = 1.13626e-10, global = 5.58023e-12, cumulative = 6.38849e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000128558, Final residual = 8.15599e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000190846, Final residual = 5.83931e-06, No Iterations 5
ExecutionTime = 50.07 s ClockTime = 50 s
Time = 4.68
Courant Number mean: 0.113441 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.18887e-05, Final residual = 5.68294e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.82483e-05, Final residual = 4.67802e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00019112, Final residual = 1.08224e-05, No Iterations 9
time step continuity errors : sum local = 2.11653e-09, global = -8.55334e-11, cumulative = 6.3884e-06
GAMG: Solving for p, Initial residual = 0.000145348, Final residual = 5.76963e-07, No Iterations 17
time step continuity errors : sum local = 1.12885e-10, global = 5.54928e-12, cumulative = 6.38841e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000127844, Final residual = 8.10565e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000189768, Final residual = 5.80431e-06, No Iterations 5
ExecutionTime = 50.1 s ClockTime = 50 s
Time = 4.6825
Courant Number mean: 0.113442 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.18385e-05, Final residual = 5.67577e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.81185e-05, Final residual = 4.66657e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000190074, Final residual = 1.07322e-05, No Iterations 9
time step continuity errors : sum local = 2.09897e-09, global = -8.51729e-11, cumulative = 6.38832e-06
GAMG: Solving for p, Initial residual = 0.000144554, Final residual = 5.73181e-07, No Iterations 17
time step continuity errors : sum local = 1.12148e-10, global = 5.51856e-12, cumulative = 6.38833e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000127132, Final residual = 8.05527e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000188692, Final residual = 5.769e-06, No Iterations 5
ExecutionTime = 50.13 s ClockTime = 50 s
Time = 4.685
Courant Number mean: 0.113443 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.17884e-05, Final residual = 5.66871e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.79892e-05, Final residual = 4.65512e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000189, Final residual = 1.06428e-05, No Iterations 9
time step continuity errors : sum local = 2.08155e-09, global = -8.48231e-11, cumulative = 6.38824e-06
GAMG: Solving for p, Initial residual = 0.000143759, Final residual = 5.69421e-07, No Iterations 17
time step continuity errors : sum local = 1.11415e-10, global = 5.48809e-12, cumulative = 6.38825e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00012642, Final residual = 8.00489e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000187619, Final residual = 5.73417e-06, No Iterations 5
ExecutionTime = 50.16 s ClockTime = 50 s
Time = 4.6875
Courant Number mean: 0.113444 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.17385e-05, Final residual = 5.6618e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.78596e-05, Final residual = 4.64452e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000187938, Final residual = 1.05537e-05, No Iterations 9
time step continuity errors : sum local = 2.06418e-09, global = -8.44843e-11, cumulative = 6.38816e-06
GAMG: Solving for p, Initial residual = 0.000142966, Final residual = 5.65687e-07, No Iterations 17
time step continuity errors : sum local = 1.10687e-10, global = 5.45788e-12, cumulative = 6.38817e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000125709, Final residual = 7.9551e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000186548, Final residual = 9.9892e-06, No Iterations 4
ExecutionTime = 50.18 s ClockTime = 51 s
Time = 4.69
Courant Number mean: 0.113445 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.16848e-05, Final residual = 5.65342e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.77152e-05, Final residual = 4.63024e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000187427, Final residual = 1.05236e-05, No Iterations 9
time step continuity errors : sum local = 2.05837e-09, global = -8.44547e-11, cumulative = 6.38809e-06
GAMG: Solving for p, Initial residual = 0.000142149, Final residual = 5.59571e-07, No Iterations 17
time step continuity errors : sum local = 1.09494e-10, global = 5.41422e-12, cumulative = 6.38809e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000124938, Final residual = 7.89589e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000185439, Final residual = 9.93202e-06, No Iterations 4
ExecutionTime = 50.21 s ClockTime = 51 s
Time = 4.6925
Courant Number mean: 0.113446 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.16325e-05, Final residual = 5.64595e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.75799e-05, Final residual = 4.61853e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.0001841, Final residual = 1.04062e-05, No Iterations 9
time step continuity errors : sum local = 2.03546e-09, global = -8.391e-11, cumulative = 6.38801e-06
GAMG: Solving for p, Initial residual = 0.000141036, Final residual = 5.56294e-07, No Iterations 17
time step continuity errors : sum local = 1.08855e-10, global = 5.38845e-12, cumulative = 6.38801e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000124171, Final residual = 7.83665e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00018434, Final residual = 9.87471e-06, No Iterations 4
ExecutionTime = 50.23 s ClockTime = 51 s
Time = 4.695
Courant Number mean: 0.113447 max: 0.6167
smoothSolver: Solving for Ux, Initial residual = 2.15797e-05, Final residual = 5.63799e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.74475e-05, Final residual = 4.60765e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000183013, Final residual = 1.03243e-05, No Iterations 9
time step continuity errors : sum local = 2.0195e-09, global = -8.36227e-11, cumulative = 6.38793e-06
GAMG: Solving for p, Initial residual = 0.000140217, Final residual = 5.5276e-07, No Iterations 17
time step continuity errors : sum local = 1.08166e-10, global = 5.36021e-12, cumulative = 6.38793e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000123407, Final residual = 7.77817e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000183251, Final residual = 9.81766e-06, No Iterations 4
ExecutionTime = 50.26 s ClockTime = 51 s
Time = 4.6975
Courant Number mean: 0.113447 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.15273e-05, Final residual = 5.63033e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.73176e-05, Final residual = 4.59695e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000181921, Final residual = 1.02372e-05, No Iterations 9
time step continuity errors : sum local = 2.00253e-09, global = -8.32678e-11, cumulative = 6.38785e-06
GAMG: Solving for p, Initial residual = 0.00013939, Final residual = 5.49314e-07, No Iterations 17
time step continuity errors : sum local = 1.07494e-10, global = 5.33193e-12, cumulative = 6.38786e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000122646, Final residual = 7.72041e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000182171, Final residual = 9.76083e-06, No Iterations 4
ExecutionTime = 50.28 s ClockTime = 51 s
Time = 4.7
Courant Number mean: 0.113448 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.14747e-05, Final residual = 5.62266e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.71904e-05, Final residual = 4.58661e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000181214, Final residual = 1.01514e-05, No Iterations 9
time step continuity errors : sum local = 1.98579e-09, global = -8.29531e-11, cumulative = 6.38777e-06
GAMG: Solving for p, Initial residual = 0.000138591, Final residual = 5.45909e-07, No Iterations 17
time step continuity errors : sum local = 1.06829e-10, global = 5.30426e-12, cumulative = 6.38778e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000121888, Final residual = 7.66293e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000181098, Final residual = 9.70451e-06, No Iterations 4
ExecutionTime = 50.34 s ClockTime = 51 s
Time = 4.7025
Courant Number mean: 0.113449 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.14222e-05, Final residual = 5.61501e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.70629e-05, Final residual = 4.57652e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000180191, Final residual = 1.0066e-05, No Iterations 9
time step continuity errors : sum local = 1.96914e-09, global = -8.26415e-11, cumulative = 6.3877e-06
GAMG: Solving for p, Initial residual = 0.0001378, Final residual = 5.42521e-07, No Iterations 17
time step continuity errors : sum local = 1.06169e-10, global = 5.27677e-12, cumulative = 6.3877e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000121134, Final residual = 7.60654e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000180031, Final residual = 9.64847e-06, No Iterations 4
ExecutionTime = 50.36 s ClockTime = 51 s
Time = 4.705
Courant Number mean: 0.11345 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.13697e-05, Final residual = 5.60739e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.69365e-05, Final residual = 4.56657e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000179055, Final residual = 9.98176e-06, No Iterations 9
time step continuity errors : sum local = 1.95271e-09, global = -8.23509e-11, cumulative = 6.38762e-06
GAMG: Solving for p, Initial residual = 0.00013702, Final residual = 5.39156e-07, No Iterations 17
time step continuity errors : sum local = 1.05512e-10, global = 5.24958e-12, cumulative = 6.38762e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000120382, Final residual = 7.55067e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000178972, Final residual = 9.59258e-06, No Iterations 4
ExecutionTime = 50.39 s ClockTime = 51 s
Time = 4.7075
Courant Number mean: 0.113451 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.13179e-05, Final residual = 5.59975e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.6811e-05, Final residual = 4.55694e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000177955, Final residual = 9.89799e-06, No Iterations 9
time step continuity errors : sum local = 1.93637e-09, global = -8.20739e-11, cumulative = 6.38754e-06
GAMG: Solving for p, Initial residual = 0.00013625, Final residual = 5.35813e-07, No Iterations 17
time step continuity errors : sum local = 1.0486e-10, global = 5.22267e-12, cumulative = 6.38755e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000119633, Final residual = 7.49529e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000177919, Final residual = 9.53623e-06, No Iterations 4
ExecutionTime = 50.41 s ClockTime = 51 s
Time = 4.71
Courant Number mean: 0.113452 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.12664e-05, Final residual = 5.59208e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.6687e-05, Final residual = 4.54748e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000176882, Final residual = 9.81474e-06, No Iterations 9
time step continuity errors : sum local = 1.92013e-09, global = -8.18124e-11, cumulative = 6.38747e-06
GAMG: Solving for p, Initial residual = 0.000135491, Final residual = 9.9969e-07, No Iterations 16
time step continuity errors : sum local = 1.95646e-10, global = -1.52325e-11, cumulative = 6.38745e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000118889, Final residual = 7.44037e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000176871, Final residual = 9.47979e-06, No Iterations 4
ExecutionTime = 50.44 s ClockTime = 51 s
Time = 4.7125
Courant Number mean: 0.113452 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.12148e-05, Final residual = 5.58425e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.65644e-05, Final residual = 4.53822e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000175815, Final residual = 9.72802e-06, No Iterations 9
time step continuity errors : sum local = 1.90322e-09, global = -8.14902e-11, cumulative = 6.38737e-06
GAMG: Solving for p, Initial residual = 0.000134718, Final residual = 9.93803e-07, No Iterations 16
time step continuity errors : sum local = 1.94497e-10, global = -1.51174e-11, cumulative = 6.38735e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000118147, Final residual = 7.3859e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000175829, Final residual = 9.42377e-06, No Iterations 4
ExecutionTime = 50.47 s ClockTime = 51 s
Time = 4.715
Courant Number mean: 0.113453 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.1163e-05, Final residual = 5.57639e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.64424e-05, Final residual = 4.529e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000174846, Final residual = 9.65016e-06, No Iterations 9
time step continuity errors : sum local = 1.88803e-09, global = -8.13047e-11, cumulative = 6.38727e-06
GAMG: Solving for p, Initial residual = 0.000133984, Final residual = 9.96371e-07, No Iterations 15
time step continuity errors : sum local = 1.95004e-10, global = 8.91163e-12, cumulative = 6.38728e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000117409, Final residual = 7.33185e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000174792, Final residual = 9.36829e-06, No Iterations 4
ExecutionTime = 50.49 s ClockTime = 51 s
Time = 4.7175
Courant Number mean: 0.113454 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.11115e-05, Final residual = 5.56868e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.63175e-05, Final residual = 4.51998e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00017419, Final residual = 9.49233e-06, No Iterations 9
time step continuity errors : sum local = 1.8572e-09, global = -8.07288e-11, cumulative = 6.3872e-06
GAMG: Solving for p, Initial residual = 0.000133046, Final residual = 9.90711e-07, No Iterations 15
time step continuity errors : sum local = 1.93899e-10, global = 8.88256e-12, cumulative = 6.38721e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000116675, Final residual = 7.2782e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000173759, Final residual = 9.31295e-06, No Iterations 4
ExecutionTime = 50.52 s ClockTime = 51 s
Time = 4.72
Courant Number mean: 0.113455 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.10589e-05, Final residual = 5.56033e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.61968e-05, Final residual = 4.51131e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000172627, Final residual = 9.42208e-06, No Iterations 9
time step continuity errors : sum local = 1.8435e-09, global = -8.08597e-11, cumulative = 6.38713e-06
GAMG: Solving for p, Initial residual = 0.000132316, Final residual = 9.83769e-07, No Iterations 15
time step continuity errors : sum local = 1.92544e-10, global = 8.83582e-12, cumulative = 6.38714e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000115943, Final residual = 7.22438e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000172731, Final residual = 9.25772e-06, No Iterations 4
ExecutionTime = 50.55 s ClockTime = 51 s
Time = 4.7225
Courant Number mean: 0.113456 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.10065e-05, Final residual = 5.55209e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.60768e-05, Final residual = 4.50274e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000172983, Final residual = 9.34078e-06, No Iterations 9
time step continuity errors : sum local = 1.82764e-09, global = -8.06766e-11, cumulative = 6.38706e-06
GAMG: Solving for p, Initial residual = 0.000131653, Final residual = 9.7747e-07, No Iterations 15
time step continuity errors : sum local = 1.91315e-10, global = 8.79521e-12, cumulative = 6.38707e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000115214, Final residual = 7.17143e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000171708, Final residual = 9.20267e-06, No Iterations 4
ExecutionTime = 50.57 s ClockTime = 51 s
Time = 4.725
Courant Number mean: 0.113456 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.09543e-05, Final residual = 5.54364e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.59608e-05, Final residual = 4.49439e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000171149, Final residual = 9.26353e-06, No Iterations 9
time step continuity errors : sum local = 1.81257e-09, global = -8.05043e-11, cumulative = 6.38699e-06
GAMG: Solving for p, Initial residual = 0.000130876, Final residual = 9.71158e-07, No Iterations 15
time step continuity errors : sum local = 1.90083e-10, global = 8.7551e-12, cumulative = 6.38699e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000114488, Final residual = 7.11888e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00017069, Final residual = 9.14784e-06, No Iterations 4
ExecutionTime = 50.6 s ClockTime = 51 s
Time = 4.7275
Courant Number mean: 0.113457 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.09019e-05, Final residual = 5.53512e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.58439e-05, Final residual = 4.48623e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000170112, Final residual = 9.18664e-06, No Iterations 9
time step continuity errors : sum local = 1.79757e-09, global = -8.03319e-11, cumulative = 6.38691e-06
GAMG: Solving for p, Initial residual = 0.000130156, Final residual = 9.64904e-07, No Iterations 15
time step continuity errors : sum local = 1.88863e-10, global = 8.71556e-12, cumulative = 6.38692e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000113766, Final residual = 7.06634e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000169675, Final residual = 9.09247e-06, No Iterations 4
ExecutionTime = 50.62 s ClockTime = 51 s
Time = 4.73
Courant Number mean: 0.113458 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.08502e-05, Final residual = 5.52734e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.57273e-05, Final residual = 4.47814e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000168498, Final residual = 9.1122e-06, No Iterations 9
time step continuity errors : sum local = 1.78305e-09, global = -8.01595e-11, cumulative = 6.38684e-06
GAMG: Solving for p, Initial residual = 0.000129566, Final residual = 9.58198e-07, No Iterations 15
time step continuity errors : sum local = 1.87553e-10, global = 8.66913e-12, cumulative = 6.38685e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000113046, Final residual = 7.01407e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000168664, Final residual = 9.03748e-06, No Iterations 4
ExecutionTime = 50.65 s ClockTime = 51 s
Time = 4.7325
Courant Number mean: 0.113459 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.07994e-05, Final residual = 5.51983e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.56104e-05, Final residual = 4.47015e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000167752, Final residual = 9.03723e-06, No Iterations 9
time step continuity errors : sum local = 1.76842e-09, global = -7.99953e-11, cumulative = 6.38677e-06
GAMG: Solving for p, Initial residual = 0.000128918, Final residual = 9.52115e-07, No Iterations 15
time step continuity errors : sum local = 1.86366e-10, global = 8.63192e-12, cumulative = 6.38678e-06
smoothSolver: Solving for epsilon, Initial residual = 0.00011233, Final residual = 6.96244e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000167657, Final residual = 8.98332e-06, No Iterations 4
ExecutionTime = 50.67 s ClockTime = 51 s
Time = 4.735
Courant Number mean: 0.11346 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.07486e-05, Final residual = 5.51232e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.54936e-05, Final residual = 4.46219e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000166991, Final residual = 8.96514e-06, No Iterations 9
time step continuity errors : sum local = 1.75436e-09, global = -7.98321e-11, cumulative = 6.3867e-06
GAMG: Solving for p, Initial residual = 0.000128262, Final residual = 9.46141e-07, No Iterations 15
time step continuity errors : sum local = 1.852e-10, global = 8.59647e-12, cumulative = 6.38671e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000111617, Final residual = 6.91038e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000166654, Final residual = 8.92909e-06, No Iterations 4
ExecutionTime = 50.7 s ClockTime = 51 s
Time = 4.7375
Courant Number mean: 0.11346 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.06978e-05, Final residual = 5.50474e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.53778e-05, Final residual = 4.45435e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000166163, Final residual = 8.89424e-06, No Iterations 9
time step continuity errors : sum local = 1.74052e-09, global = -7.96655e-11, cumulative = 6.38663e-06
GAMG: Solving for p, Initial residual = 0.000127614, Final residual = 9.4011e-07, No Iterations 15
time step continuity errors : sum local = 1.84023e-10, global = 8.56011e-12, cumulative = 6.38664e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000110908, Final residual = 6.85933e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000165655, Final residual = 8.87499e-06, No Iterations 4
ExecutionTime = 50.72 s ClockTime = 51 s
Time = 4.74
Courant Number mean: 0.113461 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.06469e-05, Final residual = 5.49709e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.52634e-05, Final residual = 4.4466e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.0001653, Final residual = 8.82434e-06, No Iterations 9
time step continuity errors : sum local = 1.72688e-09, global = -7.95013e-11, cumulative = 6.38656e-06
GAMG: Solving for p, Initial residual = 0.000126978, Final residual = 9.3409e-07, No Iterations 15
time step continuity errors : sum local = 1.82848e-10, global = 8.52386e-12, cumulative = 6.38657e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000110201, Final residual = 6.80855e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000164659, Final residual = 8.82103e-06, No Iterations 4
ExecutionTime = 50.74 s ClockTime = 51 s
Time = 4.7425
Courant Number mean: 0.113462 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.05966e-05, Final residual = 5.48956e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.51492e-05, Final residual = 4.43888e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00016444, Final residual = 8.75509e-06, No Iterations 9
time step continuity errors : sum local = 1.71337e-09, global = -7.93492e-11, cumulative = 6.38649e-06
GAMG: Solving for p, Initial residual = 0.000126346, Final residual = 9.28101e-07, No Iterations 15
time step continuity errors : sum local = 1.81678e-10, global = 8.48807e-12, cumulative = 6.3865e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000109498, Final residual = 6.75806e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000163668, Final residual = 8.76715e-06, No Iterations 4
ExecutionTime = 50.77 s ClockTime = 51 s
Time = 4.745
Courant Number mean: 0.113463 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.05474e-05, Final residual = 5.48243e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.5035e-05, Final residual = 4.43125e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000163576, Final residual = 8.68616e-06, No Iterations 9
time step continuity errors : sum local = 1.69992e-09, global = -7.92188e-11, cumulative = 6.38642e-06
GAMG: Solving for p, Initial residual = 0.000125721, Final residual = 9.22164e-07, No Iterations 15
time step continuity errors : sum local = 1.80519e-10, global = 8.45301e-12, cumulative = 6.38642e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000108797, Final residual = 6.70782e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00016268, Final residual = 8.71307e-06, No Iterations 4
ExecutionTime = 50.79 s ClockTime = 51 s
Time = 4.7475
Courant Number mean: 0.113463 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.04985e-05, Final residual = 5.47538e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.49211e-05, Final residual = 4.42363e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000162711, Final residual = 8.61783e-06, No Iterations 9
time step continuity errors : sum local = 1.68659e-09, global = -7.90687e-11, cumulative = 6.38635e-06
GAMG: Solving for p, Initial residual = 0.000125108, Final residual = 9.16185e-07, No Iterations 15
time step continuity errors : sum local = 1.79352e-10, global = 8.41624e-12, cumulative = 6.38635e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000108099, Final residual = 6.65785e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000161695, Final residual = 8.65945e-06, No Iterations 4
ExecutionTime = 50.81 s ClockTime = 51 s
Time = 4.75
Courant Number mean: 0.113464 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.04496e-05, Final residual = 5.46832e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.48075e-05, Final residual = 4.4161e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00016185, Final residual = 8.54838e-06, No Iterations 9
time step continuity errors : sum local = 1.67304e-09, global = -7.89909e-11, cumulative = 6.38627e-06
GAMG: Solving for p, Initial residual = 0.000124497, Final residual = 9.10348e-07, No Iterations 15
time step continuity errors : sum local = 1.78213e-10, global = 8.3826e-12, cumulative = 6.38628e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000107404, Final residual = 6.60762e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000160714, Final residual = 8.60492e-06, No Iterations 4
ExecutionTime = 50.84 s ClockTime = 51 s
Time = 4.7525
Courant Number mean: 0.113465 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.04003e-05, Final residual = 5.46124e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.46942e-05, Final residual = 4.40856e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000161227, Final residual = 8.47831e-06, No Iterations 9
time step continuity errors : sum local = 1.65936e-09, global = -7.89277e-11, cumulative = 6.3862e-06
GAMG: Solving for p, Initial residual = 0.000123899, Final residual = 9.0456e-07, No Iterations 15
time step continuity errors : sum local = 1.77083e-10, global = 8.34986e-12, cumulative = 6.38621e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000106713, Final residual = 6.55773e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000159737, Final residual = 8.55131e-06, No Iterations 4
ExecutionTime = 50.87 s ClockTime = 51 s
Time = 4.755
Courant Number mean: 0.113466 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.0351e-05, Final residual = 5.45406e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.45814e-05, Final residual = 4.40097e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000160293, Final residual = 8.40903e-06, No Iterations 9
time step continuity errors : sum local = 1.64585e-09, global = -7.88957e-11, cumulative = 6.38613e-06
GAMG: Solving for p, Initial residual = 0.000123302, Final residual = 8.98811e-07, No Iterations 15
time step continuity errors : sum local = 1.75961e-10, global = 8.3179e-12, cumulative = 6.38614e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000106026, Final residual = 6.50838e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000158762, Final residual = 8.49834e-06, No Iterations 4
ExecutionTime = 50.89 s ClockTime = 51 s
Time = 4.7575
Courant Number mean: 0.113466 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.03017e-05, Final residual = 5.44682e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.44687e-05, Final residual = 4.39342e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000159426, Final residual = 8.33348e-06, No Iterations 9
time step continuity errors : sum local = 1.6311e-09, global = -7.90334e-11, cumulative = 6.38606e-06
GAMG: Solving for p, Initial residual = 0.000122709, Final residual = 8.93099e-07, No Iterations 15
time step continuity errors : sum local = 1.74847e-10, global = 8.28746e-12, cumulative = 6.38607e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000105342, Final residual = 6.45948e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000157791, Final residual = 8.44535e-06, No Iterations 4
ExecutionTime = 50.92 s ClockTime = 51 s
Time = 4.76
Courant Number mean: 0.113467 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.02524e-05, Final residual = 5.43956e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.4356e-05, Final residual = 4.38591e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000158635, Final residual = 8.26574e-06, No Iterations 9
time step continuity errors : sum local = 1.61789e-09, global = -7.90277e-11, cumulative = 6.38599e-06
GAMG: Solving for p, Initial residual = 0.000122129, Final residual = 8.87432e-07, No Iterations 15
time step continuity errors : sum local = 1.73741e-10, global = 8.25699e-12, cumulative = 6.386e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000104661, Final residual = 6.41083e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000156824, Final residual = 8.39225e-06, No Iterations 4
ExecutionTime = 50.94 s ClockTime = 51 s
Time = 4.7625
Courant Number mean: 0.113468 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.02028e-05, Final residual = 5.43222e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.42432e-05, Final residual = 4.37832e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000158364, Final residual = 8.20017e-06, No Iterations 9
time step continuity errors : sum local = 1.6051e-09, global = -7.90189e-11, cumulative = 6.38592e-06
GAMG: Solving for p, Initial residual = 0.000121556, Final residual = 8.8184e-07, No Iterations 15
time step continuity errors : sum local = 1.7265e-10, global = 8.2277e-12, cumulative = 6.38593e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000103982, Final residual = 6.36226e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000155861, Final residual = 8.33928e-06, No Iterations 4
ExecutionTime = 50.97 s ClockTime = 51 s
Time = 4.765
Courant Number mean: 0.113468 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.01535e-05, Final residual = 5.42475e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.41303e-05, Final residual = 4.37068e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000157398, Final residual = 8.13499e-06, No Iterations 9
time step continuity errors : sum local = 1.59238e-09, global = -7.90227e-11, cumulative = 6.38585e-06
GAMG: Solving for p, Initial residual = 0.000120986, Final residual = 8.76265e-07, No Iterations 15
time step continuity errors : sum local = 1.71562e-10, global = 8.1987e-12, cumulative = 6.38586e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000103307, Final residual = 6.31423e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000154902, Final residual = 8.28549e-06, No Iterations 4
ExecutionTime = 51 s ClockTime = 51 s
Time = 4.7675
Courant Number mean: 0.113469 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.01042e-05, Final residual = 5.41716e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.40171e-05, Final residual = 4.36301e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000159641, Final residual = 8.07078e-06, No Iterations 9
time step continuity errors : sum local = 1.57986e-09, global = -7.90087e-11, cumulative = 6.38578e-06
GAMG: Solving for p, Initial residual = 0.000120557, Final residual = 8.70044e-07, No Iterations 15
time step continuity errors : sum local = 1.70348e-10, global = 8.15941e-12, cumulative = 6.38579e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000102634, Final residual = 6.26637e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000153946, Final residual = 8.23292e-06, No Iterations 4
ExecutionTime = 51.02 s ClockTime = 51 s
Time = 4.77
Courant Number mean: 0.11347 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.00545e-05, Final residual = 5.40943e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.39019e-05, Final residual = 4.35536e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000155896, Final residual = 8.00619e-06, No Iterations 9
time step continuity errors : sum local = 1.56726e-09, global = -7.90614e-11, cumulative = 6.38571e-06
GAMG: Solving for p, Initial residual = 0.000119901, Final residual = 8.65484e-07, No Iterations 15
time step continuity errors : sum local = 1.69459e-10, global = 8.14577e-12, cumulative = 6.38572e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000101965, Final residual = 6.21821e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000152994, Final residual = 8.18044e-06, No Iterations 4
ExecutionTime = 51.05 s ClockTime = 51 s
Time = 4.7725
Courant Number mean: 0.11347 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 2.00046e-05, Final residual = 5.40158e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.37898e-05, Final residual = 4.34767e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000154957, Final residual = 7.94577e-06, No Iterations 9
time step continuity errors : sum local = 1.55547e-09, global = -7.90824e-11, cumulative = 6.38564e-06
GAMG: Solving for p, Initial residual = 0.000119329, Final residual = 8.60133e-07, No Iterations 15
time step continuity errors : sum local = 1.68415e-10, global = 8.1207e-12, cumulative = 6.38565e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000101299, Final residual = 6.17054e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000152045, Final residual = 8.12766e-06, No Iterations 4
ExecutionTime = 51.07 s ClockTime = 51 s
Time = 4.775
Courant Number mean: 0.113471 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.99546e-05, Final residual = 5.39364e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.36795e-05, Final residual = 4.34017e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00015407, Final residual = 7.88491e-06, No Iterations 9
time step continuity errors : sum local = 1.5436e-09, global = -7.91184e-11, cumulative = 6.38557e-06
GAMG: Solving for p, Initial residual = 0.000118765, Final residual = 8.54814e-07, No Iterations 15
time step continuity errors : sum local = 1.67377e-10, global = 8.09633e-12, cumulative = 6.38558e-06
smoothSolver: Solving for epsilon, Initial residual = 0.000100637, Final residual = 6.12309e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000151099, Final residual = 8.07535e-06, No Iterations 4
ExecutionTime = 51.09 s ClockTime = 51 s
Time = 4.7775
Courant Number mean: 0.113472 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.99042e-05, Final residual = 5.38555e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.35693e-05, Final residual = 4.33258e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000153209, Final residual = 7.8256e-06, No Iterations 9
time step continuity errors : sum local = 1.53203e-09, global = -7.91579e-11, cumulative = 6.3855e-06
GAMG: Solving for p, Initial residual = 0.000118206, Final residual = 8.49605e-07, No Iterations 15
time step continuity errors : sum local = 1.6636e-10, global = 8.07358e-12, cumulative = 6.3855e-06
smoothSolver: Solving for epsilon, Initial residual = 9.99771e-05, Final residual = 6.07599e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000150157, Final residual = 8.02284e-06, No Iterations 4
ExecutionTime = 51.12 s ClockTime = 52 s
Time = 4.78
Courant Number mean: 0.113472 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.98535e-05, Final residual = 5.37729e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.34594e-05, Final residual = 4.32507e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000152374, Final residual = 7.76693e-06, No Iterations 9
time step continuity errors : sum local = 1.52058e-09, global = -7.91945e-11, cumulative = 6.38542e-06
GAMG: Solving for p, Initial residual = 0.000117645, Final residual = 8.44438e-07, No Iterations 15
time step continuity errors : sum local = 1.65352e-10, global = 8.0519e-12, cumulative = 6.38543e-06
smoothSolver: Solving for epsilon, Initial residual = 9.9321e-05, Final residual = 6.0288e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000149218, Final residual = 7.96979e-06, No Iterations 4
ExecutionTime = 51.15 s ClockTime = 52 s
Time = 4.7825
Courant Number mean: 0.113473 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.98025e-05, Final residual = 5.36889e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.33502e-05, Final residual = 4.31749e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000151528, Final residual = 7.71042e-06, No Iterations 9
time step continuity errors : sum local = 1.50956e-09, global = -7.92466e-11, cumulative = 6.38535e-06
GAMG: Solving for p, Initial residual = 0.00011709, Final residual = 8.39362e-07, No Iterations 15
time step continuity errors : sum local = 1.64362e-10, global = 8.03169e-12, cumulative = 6.38536e-06
smoothSolver: Solving for epsilon, Initial residual = 9.86676e-05, Final residual = 5.98168e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000148283, Final residual = 7.91745e-06, No Iterations 4
ExecutionTime = 51.17 s ClockTime = 52 s
Time = 4.785
Courant Number mean: 0.113474 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.97512e-05, Final residual = 5.36036e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.32407e-05, Final residual = 4.30984e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000150707, Final residual = 7.65455e-06, No Iterations 9
time step continuity errors : sum local = 1.49865e-09, global = -7.92958e-11, cumulative = 6.38528e-06
GAMG: Solving for p, Initial residual = 0.000116544, Final residual = 8.34356e-07, No Iterations 15
time step continuity errors : sum local = 1.63385e-10, global = 8.01298e-12, cumulative = 6.38529e-06
smoothSolver: Solving for epsilon, Initial residual = 9.8017e-05, Final residual = 5.93498e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000147351, Final residual = 7.86562e-06, No Iterations 4
ExecutionTime = 51.2 s ClockTime = 52 s
Time = 4.7875
Courant Number mean: 0.113474 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.96995e-05, Final residual = 5.35167e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.3132e-05, Final residual = 4.30211e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00014987, Final residual = 7.59967e-06, No Iterations 9
time step continuity errors : sum local = 1.48795e-09, global = -7.93497e-11, cumulative = 6.38521e-06
GAMG: Solving for p, Initial residual = 0.000115998, Final residual = 8.29449e-07, No Iterations 15
time step continuity errors : sum local = 1.62427e-10, global = 7.99574e-12, cumulative = 6.38522e-06
smoothSolver: Solving for epsilon, Initial residual = 9.73696e-05, Final residual = 5.88839e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000146423, Final residual = 7.81292e-06, No Iterations 4
ExecutionTime = 51.22 s ClockTime = 52 s
Time = 4.79
Courant Number mean: 0.113475 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.96474e-05, Final residual = 5.34286e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.30236e-05, Final residual = 4.29431e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000149004, Final residual = 7.54605e-06, No Iterations 9
time step continuity errors : sum local = 1.47749e-09, global = -7.9407e-11, cumulative = 6.38514e-06
GAMG: Solving for p, Initial residual = 0.00011546, Final residual = 8.24635e-07, No Iterations 15
time step continuity errors : sum local = 1.61488e-10, global = 7.98006e-12, cumulative = 6.38515e-06
smoothSolver: Solving for epsilon, Initial residual = 9.67254e-05, Final residual = 5.84206e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000145498, Final residual = 7.7614e-06, No Iterations 4
ExecutionTime = 51.25 s ClockTime = 52 s
Time = 4.7925
Courant Number mean: 0.113476 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.95957e-05, Final residual = 5.33393e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.29153e-05, Final residual = 4.2865e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000148192, Final residual = 7.49359e-06, No Iterations 9
time step continuity errors : sum local = 1.46725e-09, global = -7.9466e-11, cumulative = 6.38507e-06
GAMG: Solving for p, Initial residual = 0.000114929, Final residual = 8.19912e-07, No Iterations 15
time step continuity errors : sum local = 1.60566e-10, global = 7.96608e-12, cumulative = 6.38508e-06
smoothSolver: Solving for epsilon, Initial residual = 9.60847e-05, Final residual = 5.79606e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000144576, Final residual = 7.70935e-06, No Iterations 4
ExecutionTime = 51.27 s ClockTime = 52 s
Time = 4.795
Courant Number mean: 0.113476 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.95438e-05, Final residual = 5.32488e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.28073e-05, Final residual = 4.27872e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000147384, Final residual = 7.44259e-06, No Iterations 9
time step continuity errors : sum local = 1.4573e-09, global = -7.95251e-11, cumulative = 6.385e-06
GAMG: Solving for p, Initial residual = 0.000114401, Final residual = 8.15289e-07, No Iterations 15
time step continuity errors : sum local = 1.59664e-10, global = 7.95395e-12, cumulative = 6.385e-06
smoothSolver: Solving for epsilon, Initial residual = 9.54474e-05, Final residual = 5.75031e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000143658, Final residual = 7.65847e-06, No Iterations 4
ExecutionTime = 51.29 s ClockTime = 52 s
Time = 4.7975
Courant Number mean: 0.113477 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.94918e-05, Final residual = 5.3157e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.26992e-05, Final residual = 4.2711e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000146411, Final residual = 7.39334e-06, No Iterations 9
time step continuity errors : sum local = 1.4477e-09, global = -7.95881e-11, cumulative = 6.38492e-06
GAMG: Solving for p, Initial residual = 0.000113878, Final residual = 8.10755e-07, No Iterations 15
time step continuity errors : sum local = 1.58779e-10, global = 7.94369e-12, cumulative = 6.38493e-06
smoothSolver: Solving for epsilon, Initial residual = 9.48127e-05, Final residual = 5.70478e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000142743, Final residual = 7.60732e-06, No Iterations 4
ExecutionTime = 51.32 s ClockTime = 52 s
Time = 4.8
Courant Number mean: 0.113478 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.94395e-05, Final residual = 5.3064e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.25909e-05, Final residual = 4.26352e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00014651, Final residual = 7.3456e-06, No Iterations 9
time step continuity errors : sum local = 1.43838e-09, global = -7.96486e-11, cumulative = 6.38485e-06
GAMG: Solving for p, Initial residual = 0.000113357, Final residual = 8.06322e-07, No Iterations 15
time step continuity errors : sum local = 1.57914e-10, global = 7.93553e-12, cumulative = 6.38486e-06
smoothSolver: Solving for epsilon, Initial residual = 9.41811e-05, Final residual = 5.65947e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000141831, Final residual = 7.55664e-06, No Iterations 4
ExecutionTime = 51.36 s ClockTime = 52 s
Time = 4.8025
Courant Number mean: 0.113478 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.9387e-05, Final residual = 5.29697e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.24827e-05, Final residual = 4.2559e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000145559, Final residual = 7.30019e-06, No Iterations 9
time step continuity errors : sum local = 1.42953e-09, global = -7.97109e-11, cumulative = 6.38478e-06
GAMG: Solving for p, Initial residual = 0.000112832, Final residual = 8.01999e-07, No Iterations 15
time step continuity errors : sum local = 1.57071e-10, global = 7.92958e-12, cumulative = 6.38479e-06
smoothSolver: Solving for epsilon, Initial residual = 9.35524e-05, Final residual = 5.61437e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000140923, Final residual = 7.50517e-06, No Iterations 4
ExecutionTime = 51.38 s ClockTime = 52 s
Time = 4.805
Courant Number mean: 0.113479 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.93342e-05, Final residual = 5.2874e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.23749e-05, Final residual = 4.24821e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000144635, Final residual = 7.25645e-06, No Iterations 9
time step continuity errors : sum local = 1.421e-09, global = -7.97716e-11, cumulative = 6.38471e-06
GAMG: Solving for p, Initial residual = 0.00011231, Final residual = 7.97776e-07, No Iterations 15
time step continuity errors : sum local = 1.56247e-10, global = 7.92589e-12, cumulative = 6.38472e-06
smoothSolver: Solving for epsilon, Initial residual = 9.29273e-05, Final residual = 5.56952e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000140018, Final residual = 7.45461e-06, No Iterations 4
ExecutionTime = 51.41 s ClockTime = 52 s
Time = 4.8075
Courant Number mean: 0.11348 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.9281e-05, Final residual = 5.2777e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.22694e-05, Final residual = 4.24039e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000144486, Final residual = 7.21207e-06, No Iterations 9
time step continuity errors : sum local = 1.41234e-09, global = -7.98407e-11, cumulative = 6.38464e-06
GAMG: Solving for p, Initial residual = 0.000111799, Final residual = 7.93688e-07, No Iterations 15
time step continuity errors : sum local = 1.5545e-10, global = 7.92505e-12, cumulative = 6.38465e-06
smoothSolver: Solving for epsilon, Initial residual = 9.2305e-05, Final residual = 5.52502e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000139117, Final residual = 7.40302e-06, No Iterations 4
ExecutionTime = 51.44 s ClockTime = 52 s
Time = 4.81
Courant Number mean: 0.11348 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.92275e-05, Final residual = 5.26784e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.2165e-05, Final residual = 4.2325e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00014413, Final residual = 7.17056e-06, No Iterations 9
time step continuity errors : sum local = 1.40425e-09, global = -7.99038e-11, cumulative = 6.38457e-06
GAMG: Solving for p, Initial residual = 0.000111288, Final residual = 7.89709e-07, No Iterations 15
time step continuity errors : sum local = 1.54673e-10, global = 7.92647e-12, cumulative = 6.38457e-06
smoothSolver: Solving for epsilon, Initial residual = 9.16857e-05, Final residual = 5.48061e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000138219, Final residual = 7.35264e-06, No Iterations 4
ExecutionTime = 51.47 s ClockTime = 52 s
Time = 4.8125
Courant Number mean: 0.113481 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.91741e-05, Final residual = 5.2579e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.20605e-05, Final residual = 4.22452e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000143232, Final residual = 7.13052e-06, No Iterations 9
time step continuity errors : sum local = 1.39644e-09, global = -7.9966e-11, cumulative = 6.38449e-06
GAMG: Solving for p, Initial residual = 0.000110775, Final residual = 7.85837e-07, No Iterations 15
time step continuity errors : sum local = 1.53918e-10, global = 7.93066e-12, cumulative = 6.3845e-06
smoothSolver: Solving for epsilon, Initial residual = 9.10693e-05, Final residual = 5.43614e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000137325, Final residual = 7.30244e-06, No Iterations 4
ExecutionTime = 51.49 s ClockTime = 52 s
Time = 4.815
Courant Number mean: 0.113481 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.91206e-05, Final residual = 5.24786e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.19568e-05, Final residual = 9.98124e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000166312, Final residual = 1.26423e-05, No Iterations 9
time step continuity errors : sum local = 2.47593e-09, global = -2.29383e-10, cumulative = 6.38427e-06
GAMG: Solving for p, Initial residual = 0.000120639, Final residual = 8.11693e-07, No Iterations 17
time step continuity errors : sum local = 1.58989e-10, global = 1.27027e-11, cumulative = 6.38428e-06
smoothSolver: Solving for epsilon, Initial residual = 9.04564e-05, Final residual = 5.39225e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000136435, Final residual = 7.25251e-06, No Iterations 4
ExecutionTime = 51.52 s ClockTime = 52 s
Time = 4.8175
Courant Number mean: 0.113482 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.9043e-05, Final residual = 5.23458e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.24356e-05, Final residual = 4.37404e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000136403, Final residual = 6.991e-06, No Iterations 9
time step continuity errors : sum local = 1.36914e-09, global = -8.60316e-11, cumulative = 6.3842e-06
GAMG: Solving for p, Initial residual = 0.000104674, Final residual = 7.6105e-07, No Iterations 15
time step continuity errors : sum local = 1.49071e-10, global = 7.77334e-12, cumulative = 6.38421e-06
smoothSolver: Solving for epsilon, Initial residual = 8.98456e-05, Final residual = 5.34837e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000135548, Final residual = 7.20275e-06, No Iterations 4
ExecutionTime = 51.54 s ClockTime = 52 s
Time = 4.82
Courant Number mean: 0.113483 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.90178e-05, Final residual = 5.22808e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.16301e-05, Final residual = 9.86112e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.00016963, Final residual = 1.34781e-05, No Iterations 9
time step continuity errors : sum local = 2.63981e-09, global = -2.62138e-10, cumulative = 6.38394e-06
GAMG: Solving for p, Initial residual = 0.000121229, Final residual = 8.2627e-07, No Iterations 17
time step continuity errors : sum local = 1.61852e-10, global = 1.3111e-11, cumulative = 6.38396e-06
smoothSolver: Solving for epsilon, Initial residual = 8.92384e-05, Final residual = 5.30502e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000134665, Final residual = 7.15239e-06, No Iterations 4
ExecutionTime = 51.57 s ClockTime = 52 s
Time = 4.8225
Courant Number mean: 0.113483 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.8932e-05, Final residual = 5.21298e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.22782e-05, Final residual = 4.37126e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000135287, Final residual = 6.96039e-06, No Iterations 9
time step continuity errors : sum local = 1.36321e-09, global = -8.78256e-11, cumulative = 6.38387e-06
GAMG: Solving for p, Initial residual = 0.000104085, Final residual = 7.52152e-07, No Iterations 15
time step continuity errors : sum local = 1.47334e-10, global = 7.76543e-12, cumulative = 6.38388e-06
smoothSolver: Solving for epsilon, Initial residual = 8.86331e-05, Final residual = 5.26174e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000133785, Final residual = 7.10224e-06, No Iterations 4
ExecutionTime = 51.6 s ClockTime = 52 s
Time = 4.825
Courant Number mean: 0.113484 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.89089e-05, Final residual = 5.20681e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.14275e-05, Final residual = 9.8104e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000168583, Final residual = 1.31141e-05, No Iterations 9
time step continuity errors : sum local = 2.56863e-09, global = -2.26904e-10, cumulative = 6.38365e-06
GAMG: Solving for p, Initial residual = 0.000120557, Final residual = 8.55998e-07, No Iterations 17
time step continuity errors : sum local = 1.6768e-10, global = 1.37074e-11, cumulative = 6.38366e-06
smoothSolver: Solving for epsilon, Initial residual = 8.80318e-05, Final residual = 5.21871e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000132909, Final residual = 7.05246e-06, No Iterations 4
ExecutionTime = 51.62 s ClockTime = 52 s
Time = 4.8275
Courant Number mean: 0.113484 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.88231e-05, Final residual = 5.19118e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.20851e-05, Final residual = 4.35679e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.0001335, Final residual = 6.89745e-06, No Iterations 9
time step continuity errors : sum local = 1.35095e-09, global = -8.88313e-11, cumulative = 6.38358e-06
GAMG: Solving for p, Initial residual = 0.000103253, Final residual = 7.43564e-07, No Iterations 15
time step continuity errors : sum local = 1.45657e-10, global = 7.76939e-12, cumulative = 6.38358e-06
smoothSolver: Solving for epsilon, Initial residual = 8.74332e-05, Final residual = 5.1758e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000132036, Final residual = 7.00298e-06, No Iterations 4
ExecutionTime = 51.65 s ClockTime = 52 s
Time = 4.83
Courant Number mean: 0.113485 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.88002e-05, Final residual = 5.18497e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.12304e-05, Final residual = 9.76304e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000167266, Final residual = 1.31561e-05, No Iterations 9
time step continuity errors : sum local = 2.57698e-09, global = -2.30781e-10, cumulative = 6.38335e-06
GAMG: Solving for p, Initial residual = 0.000119674, Final residual = 8.62672e-07, No Iterations 17
time step continuity errors : sum local = 1.68994e-10, global = 1.39322e-11, cumulative = 6.38337e-06
smoothSolver: Solving for epsilon, Initial residual = 8.68381e-05, Final residual = 5.13319e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000131167, Final residual = 6.95324e-06, No Iterations 4
ExecutionTime = 51.67 s ClockTime = 52 s
Time = 4.8325
Courant Number mean: 0.113485 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.87138e-05, Final residual = 5.16898e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.18887e-05, Final residual = 4.3417e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.00013208, Final residual = 6.82296e-06, No Iterations 9
time step continuity errors : sum local = 1.33641e-09, global = -8.93653e-11, cumulative = 6.38328e-06
GAMG: Solving for p, Initial residual = 0.000102391, Final residual = 7.36349e-07, No Iterations 15
time step continuity errors : sum local = 1.44249e-10, global = 7.79404e-12, cumulative = 6.38328e-06
smoothSolver: Solving for epsilon, Initial residual = 8.62451e-05, Final residual = 5.09067e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.0001303, Final residual = 6.90425e-06, No Iterations 4
ExecutionTime = 51.7 s ClockTime = 52 s
Time = 4.835
Courant Number mean: 0.113486 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.8691e-05, Final residual = 5.16265e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.10338e-05, Final residual = 9.7156e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000165817, Final residual = 1.31944e-05, No Iterations 9
time step continuity errors : sum local = 2.5846e-09, global = -2.34944e-10, cumulative = 6.38305e-06
GAMG: Solving for p, Initial residual = 0.000118783, Final residual = 8.70292e-07, No Iterations 17
time step continuity errors : sum local = 1.70493e-10, global = 1.41743e-11, cumulative = 6.38306e-06
smoothSolver: Solving for epsilon, Initial residual = 8.56558e-05, Final residual = 5.04811e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000129439, Final residual = 6.85499e-06, No Iterations 4
ExecutionTime = 51.72 s ClockTime = 52 s
Time = 4.8375
Courant Number mean: 0.113487 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.86039e-05, Final residual = 5.14635e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.16932e-05, Final residual = 4.32632e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000130682, Final residual = 6.75118e-06, No Iterations 9
time step continuity errors : sum local = 1.32241e-09, global = -8.98922e-11, cumulative = 6.38297e-06
GAMG: Solving for p, Initial residual = 0.000101529, Final residual = 7.29654e-07, No Iterations 15
time step continuity errors : sum local = 1.42943e-10, global = 7.83492e-12, cumulative = 6.38298e-06
smoothSolver: Solving for epsilon, Initial residual = 8.50684e-05, Final residual = 5.00579e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.00012858, Final residual = 6.80604e-06, No Iterations 4
ExecutionTime = 51.75 s ClockTime = 52 s
Time = 4.84
Courant Number mean: 0.113487 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.85812e-05, Final residual = 5.1399e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.08377e-05, Final residual = 9.66756e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000164365, Final residual = 1.32326e-05, No Iterations 9
time step continuity errors : sum local = 2.5922e-09, global = -2.39531e-10, cumulative = 6.38274e-06
GAMG: Solving for p, Initial residual = 0.000117886, Final residual = 8.78747e-07, No Iterations 17
time step continuity errors : sum local = 1.72156e-10, global = 1.44351e-11, cumulative = 6.38276e-06
smoothSolver: Solving for epsilon, Initial residual = 8.44847e-05, Final residual = 4.96402e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000127726, Final residual = 6.75712e-06, No Iterations 4
ExecutionTime = 51.77 s ClockTime = 52 s
Time = 4.8425
Courant Number mean: 0.113488 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.84934e-05, Final residual = 5.1233e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.14987e-05, Final residual = 4.31063e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000129349, Final residual = 6.68285e-06, No Iterations 9
time step continuity errors : sum local = 1.30908e-09, global = -9.04281e-11, cumulative = 6.38267e-06
GAMG: Solving for p, Initial residual = 0.000100667, Final residual = 7.23603e-07, No Iterations 15
time step continuity errors : sum local = 1.41762e-10, global = 7.89356e-12, cumulative = 6.38267e-06
smoothSolver: Solving for epsilon, Initial residual = 8.39028e-05, Final residual = 4.92238e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000126874, Final residual = 6.70861e-06, No Iterations 4
ExecutionTime = 51.8 s ClockTime = 52 s
Time = 4.845
Courant Number mean: 0.113488 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.84711e-05, Final residual = 5.11675e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.06404e-05, Final residual = 9.61889e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000162968, Final residual = 1.32719e-05, No Iterations 9
time step continuity errors : sum local = 2.60001e-09, global = -2.44544e-10, cumulative = 6.38243e-06
GAMG: Solving for p, Initial residual = 0.000116995, Final residual = 8.88099e-07, No Iterations 17
time step continuity errors : sum local = 1.73995e-10, global = 1.47182e-11, cumulative = 6.38244e-06
smoothSolver: Solving for epsilon, Initial residual = 8.33245e-05, Final residual = 4.88105e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000126027, Final residual = 6.65983e-06, No Iterations 4
ExecutionTime = 51.83 s ClockTime = 52 s
Time = 4.8475
Courant Number mean: 0.113489 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.83828e-05, Final residual = 5.09982e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.13029e-05, Final residual = 4.29452e-06, No Iterations 2
GAMG: Solving for p, Initial residual = 0.000128202, Final residual = 6.61878e-06, No Iterations 9
time step continuity errors : sum local = 1.29659e-09, global = -9.0992e-11, cumulative = 6.38235e-06
GAMG: Solving for p, Initial residual = 9.98163e-05, Final residual = 7.18242e-07, No Iterations 15
time step continuity errors : sum local = 1.40717e-10, global = 7.97119e-12, cumulative = 6.38236e-06
smoothSolver: Solving for epsilon, Initial residual = 8.27484e-05, Final residual = 4.84009e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000125182, Final residual = 6.61167e-06, No Iterations 4
ExecutionTime = 51.85 s ClockTime = 52 s
Time = 4.85
Courant Number mean: 0.113489 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.83612e-05, Final residual = 5.09318e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.04412e-05, Final residual = 9.56965e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000162769, Final residual = 1.33236e-05, No Iterations 9
time step continuity errors : sum local = 2.61025e-09, global = -2.50126e-10, cumulative = 6.38211e-06
GAMG: Solving for p, Initial residual = 0.000116211, Final residual = 8.97684e-07, No Iterations 17
time step continuity errors : sum local = 1.75879e-10, global = 1.50129e-11, cumulative = 6.38213e-06
smoothSolver: Solving for epsilon, Initial residual = 8.21764e-05, Final residual = 4.79885e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000124343, Final residual = 6.56355e-06, No Iterations 4
ExecutionTime = 51.88 s ClockTime = 52 s
Time = 4.8525
Courant Number mean: 0.11349 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.8272e-05, Final residual = 5.07595e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.11004e-05, Final residual = 9.95839e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000140703, Final residual = 9.43059e-06, No Iterations 9
time step continuity errors : sum local = 1.8475e-09, global = -1.60716e-10, cumulative = 6.38197e-06
GAMG: Solving for p, Initial residual = 0.000107101, Final residual = 8.94919e-07, No Iterations 17
time step continuity errors : sum local = 1.7534e-10, global = 1.50265e-11, cumulative = 6.38198e-06
smoothSolver: Solving for epsilon, Initial residual = 8.16072e-05, Final residual = 4.75786e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000123507, Final residual = 6.51606e-06, No Iterations 4
ExecutionTime = 51.9 s ClockTime = 52 s
Time = 4.855
Courant Number mean: 0.11349 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.8226e-05, Final residual = 5.06495e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.08484e-05, Final residual = 9.84448e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000140755, Final residual = 1.04712e-05, No Iterations 9
time step continuity errors : sum local = 2.05145e-09, global = -1.92232e-10, cumulative = 6.38179e-06
GAMG: Solving for p, Initial residual = 0.000107897, Final residual = 9.13943e-07, No Iterations 17
time step continuity errors : sum local = 1.79071e-10, global = 1.55433e-11, cumulative = 6.3818e-06
smoothSolver: Solving for epsilon, Initial residual = 8.10411e-05, Final residual = 4.71734e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000122675, Final residual = 6.46855e-06, No Iterations 4
ExecutionTime = 51.93 s ClockTime = 52 s
Time = 4.8575
Courant Number mean: 0.113491 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.81673e-05, Final residual = 5.05198e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.07966e-05, Final residual = 9.8458e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000138791, Final residual = 1.01991e-05, No Iterations 9
time step continuity errors : sum local = 1.99817e-09, global = -1.85119e-10, cumulative = 6.38162e-06
GAMG: Solving for p, Initial residual = 0.000107024, Final residual = 9.21329e-07, No Iterations 17
time step continuity errors : sum local = 1.80521e-10, global = 1.58283e-11, cumulative = 6.38163e-06
smoothSolver: Solving for epsilon, Initial residual = 8.0478e-05, Final residual = 4.67705e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000121847, Final residual = 6.4212e-06, No Iterations 4
ExecutionTime = 51.95 s ClockTime = 52 s
Time = 4.86
Courant Number mean: 0.113491 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.81118e-05, Final residual = 5.03951e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.06942e-05, Final residual = 9.81764e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000138314, Final residual = 1.02646e-05, No Iterations 9
time step continuity errors : sum local = 2.01106e-09, global = -1.88364e-10, cumulative = 6.38145e-06
GAMG: Solving for p, Initial residual = 0.000106661, Final residual = 9.31246e-07, No Iterations 17
time step continuity errors : sum local = 1.82468e-10, global = 1.61693e-11, cumulative = 6.38146e-06
smoothSolver: Solving for epsilon, Initial residual = 7.99176e-05, Final residual = 4.63698e-06, No Iterations 3
smoothSolver: Solving for k, Initial residual = 0.000121022, Final residual = 6.37311e-06, No Iterations 4
ExecutionTime = 51.99 s ClockTime = 52 s
Time = 4.8625
Courant Number mean: 0.113492 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.80555e-05, Final residual = 5.02682e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.06025e-05, Final residual = 9.79632e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000137403, Final residual = 1.02404e-05, No Iterations 9
time step continuity errors : sum local = 2.00636e-09, global = -1.88792e-10, cumulative = 6.38127e-06
GAMG: Solving for p, Initial residual = 0.000106178, Final residual = 9.41367e-07, No Iterations 17
time step continuity errors : sum local = 1.84454e-10, global = 1.65379e-11, cumulative = 6.38129e-06
smoothSolver: Solving for epsilon, Initial residual = 7.93601e-05, Final residual = 9.93687e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00012023, Final residual = 6.32848e-06, No Iterations 4
ExecutionTime = 52.01 s ClockTime = 52 s
Time = 4.865
Courant Number mean: 0.113492 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.80037e-05, Final residual = 5.01543e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.05021e-05, Final residual = 9.77122e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000137342, Final residual = 1.02836e-05, No Iterations 9
time step continuity errors : sum local = 2.01487e-09, global = -1.90949e-10, cumulative = 6.3811e-06
GAMG: Solving for p, Initial residual = 0.000105527, Final residual = 9.45718e-07, No Iterations 17
time step continuity errors : sum local = 1.8531e-10, global = 1.6748e-11, cumulative = 6.38112e-06
smoothSolver: Solving for epsilon, Initial residual = 7.90046e-05, Final residual = 9.90298e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000119488, Final residual = 6.2875e-06, No Iterations 4
ExecutionTime = 52.04 s ClockTime = 53 s
Time = 4.8675
Courant Number mean: 0.113493 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.79514e-05, Final residual = 5.00352e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.04098e-05, Final residual = 9.74886e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000136642, Final residual = 1.02691e-05, No Iterations 9
time step continuity errors : sum local = 2.01206e-09, global = -1.91499e-10, cumulative = 6.38092e-06
GAMG: Solving for p, Initial residual = 0.000105128, Final residual = 9.56885e-07, No Iterations 17
time step continuity errors : sum local = 1.87501e-10, global = 1.71784e-11, cumulative = 6.38094e-06
smoothSolver: Solving for epsilon, Initial residual = 7.86387e-05, Final residual = 9.86561e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000118747, Final residual = 6.24635e-06, No Iterations 4
ExecutionTime = 52.07 s ClockTime = 53 s
Time = 4.87
Courant Number mean: 0.113493 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.78988e-05, Final residual = 4.99159e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.03147e-05, Final residual = 9.72492e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000135953, Final residual = 1.02739e-05, No Iterations 9
time step continuity errors : sum local = 2.01305e-09, global = -1.92978e-10, cumulative = 6.38075e-06
GAMG: Solving for p, Initial residual = 0.000104723, Final residual = 9.68657e-07, No Iterations 17
time step continuity errors : sum local = 1.89811e-10, global = 1.7647e-11, cumulative = 6.38077e-06
smoothSolver: Solving for epsilon, Initial residual = 7.8264e-05, Final residual = 9.82522e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000118008, Final residual = 6.20512e-06, No Iterations 4
ExecutionTime = 52.09 s ClockTime = 53 s
Time = 4.8725
Courant Number mean: 0.113494 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.7846e-05, Final residual = 4.97952e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.02201e-05, Final residual = 9.70141e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000135272, Final residual = 1.02704e-05, No Iterations 9
time step continuity errors : sum local = 2.01239e-09, global = -1.9422e-10, cumulative = 6.38057e-06
GAMG: Solving for p, Initial residual = 0.000104311, Final residual = 9.80807e-07, No Iterations 17
time step continuity errors : sum local = 1.92195e-10, global = 1.81537e-11, cumulative = 6.38059e-06
smoothSolver: Solving for epsilon, Initial residual = 7.7883e-05, Final residual = 9.78209e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00011727, Final residual = 6.16382e-06, No Iterations 4
ExecutionTime = 52.12 s ClockTime = 53 s
Time = 4.875
Courant Number mean: 0.113494 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.77933e-05, Final residual = 4.96735e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.01252e-05, Final residual = 9.67757e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000134608, Final residual = 1.0269e-05, No Iterations 9
time step continuity errors : sum local = 2.01216e-09, global = -1.95571e-10, cumulative = 6.38039e-06
GAMG: Solving for p, Initial residual = 0.000103898, Final residual = 9.93322e-07, No Iterations 17
time step continuity errors : sum local = 1.94651e-10, global = 1.86976e-11, cumulative = 6.38041e-06
smoothSolver: Solving for epsilon, Initial residual = 7.74963e-05, Final residual = 9.73708e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000116532, Final residual = 6.12249e-06, No Iterations 4
ExecutionTime = 52.15 s ClockTime = 53 s
Time = 4.8775
Courant Number mean: 0.113495 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.77401e-05, Final residual = 4.95505e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 3.00304e-05, Final residual = 9.65365e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000133951, Final residual = 1.02672e-05, No Iterations 9
time step continuity errors : sum local = 2.01184e-09, global = -1.96942e-10, cumulative = 6.38022e-06
GAMG: Solving for p, Initial residual = 0.000103482, Final residual = 6.47123e-07, No Iterations 19
time step continuity errors : sum local = 1.26812e-10, global = 1.30365e-11, cumulative = 6.38023e-06
smoothSolver: Solving for epsilon, Initial residual = 7.71051e-05, Final residual = 9.69046e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000115795, Final residual = 6.08027e-06, No Iterations 4
ExecutionTime = 52.19 s ClockTime = 53 s
Time = 4.88
Courant Number mean: 0.113495 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.76879e-05, Final residual = 4.94269e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.993e-05, Final residual = 9.6261e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000133386, Final residual = 1.03515e-05, No Iterations 9
time step continuity errors : sum local = 2.02841e-09, global = -1.99967e-10, cumulative = 6.38003e-06
GAMG: Solving for p, Initial residual = 0.000103272, Final residual = 6.60333e-07, No Iterations 19
time step continuity errors : sum local = 1.29403e-10, global = 1.36364e-11, cumulative = 6.38004e-06
smoothSolver: Solving for epsilon, Initial residual = 7.67103e-05, Final residual = 9.64185e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.00011506, Final residual = 6.03894e-06, No Iterations 4
ExecutionTime = 52.22 s ClockTime = 53 s
Time = 4.8825
Courant Number mean: 0.113496 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.76339e-05, Final residual = 4.93021e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.98379e-05, Final residual = 9.60373e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000132742, Final residual = 1.03159e-05, No Iterations 9
time step continuity errors : sum local = 2.02146e-09, global = -2.00788e-10, cumulative = 6.37984e-06
GAMG: Solving for p, Initial residual = 0.000102788, Final residual = 6.73191e-07, No Iterations 19
time step continuity errors : sum local = 1.31925e-10, global = 1.42868e-11, cumulative = 6.37986e-06
smoothSolver: Solving for epsilon, Initial residual = 7.63126e-05, Final residual = 9.59224e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000114327, Final residual = 5.99748e-06, No Iterations 4
ExecutionTime = 52.25 s ClockTime = 53 s
Time = 4.885
Courant Number mean: 0.113496 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.75804e-05, Final residual = 4.91761e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.97425e-05, Final residual = 9.57954e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000132078, Final residual = 1.0323e-05, No Iterations 9
time step continuity errors : sum local = 2.02289e-09, global = -2.02484e-10, cumulative = 6.37965e-06
GAMG: Solving for p, Initial residual = 0.000102376, Final residual = 6.86552e-07, No Iterations 19
time step continuity errors : sum local = 1.34545e-10, global = 1.49758e-11, cumulative = 6.37967e-06
smoothSolver: Solving for epsilon, Initial residual = 7.59199e-05, Final residual = 9.54197e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000113594, Final residual = 5.95559e-06, No Iterations 4
ExecutionTime = 52.28 s ClockTime = 53 s
Time = 4.8875
Courant Number mean: 0.113497 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.75266e-05, Final residual = 4.90489e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.96476e-05, Final residual = 9.55565e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000131363, Final residual = 1.03228e-05, No Iterations 9
time step continuity errors : sum local = 2.02289e-09, global = -2.04051e-10, cumulative = 6.37947e-06
GAMG: Solving for p, Initial residual = 0.000101946, Final residual = 7.00436e-07, No Iterations 19
time step continuity errors : sum local = 1.37269e-10, global = 1.57172e-11, cumulative = 6.37948e-06
smoothSolver: Solving for epsilon, Initial residual = 7.5518e-05, Final residual = 9.49052e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000112863, Final residual = 5.91437e-06, No Iterations 4
ExecutionTime = 52.31 s ClockTime = 53 s
Time = 4.89
Courant Number mean: 0.113497 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.74727e-05, Final residual = 4.89208e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.95531e-05, Final residual = 9.53167e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000130668, Final residual = 1.03264e-05, No Iterations 9
time step continuity errors : sum local = 2.02365e-09, global = -2.05765e-10, cumulative = 6.37928e-06
GAMG: Solving for p, Initial residual = 0.000101515, Final residual = 7.14818e-07, No Iterations 19
time step continuity errors : sum local = 1.40089e-10, global = 1.65034e-11, cumulative = 6.37929e-06
smoothSolver: Solving for epsilon, Initial residual = 7.51144e-05, Final residual = 9.438e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000112134, Final residual = 5.87295e-06, No Iterations 4
ExecutionTime = 52.34 s ClockTime = 53 s
Time = 4.8925
Courant Number mean: 0.113497 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.74187e-05, Final residual = 4.87919e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.94586e-05, Final residual = 9.50773e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000129971, Final residual = 1.03299e-05, No Iterations 9
time step continuity errors : sum local = 2.02437e-09, global = -2.07526e-10, cumulative = 6.37908e-06
GAMG: Solving for p, Initial residual = 0.000101083, Final residual = 7.29696e-07, No Iterations 19
time step continuity errors : sum local = 1.43007e-10, global = 1.73392e-11, cumulative = 6.3791e-06
smoothSolver: Solving for epsilon, Initial residual = 7.47092e-05, Final residual = 9.38472e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000111407, Final residual = 5.83129e-06, No Iterations 4
ExecutionTime = 52.37 s ClockTime = 53 s
Time = 4.895
Courant Number mean: 0.113498 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.73645e-05, Final residual = 4.86623e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.93645e-05, Final residual = 9.48373e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000129269, Final residual = 9.91418e-06, No Iterations 9
time step continuity errors : sum local = 1.94294e-09, global = -1.7548e-10, cumulative = 6.37893e-06
GAMG: Solving for p, Initial residual = 0.000100741, Final residual = 8.03984e-07, No Iterations 19
time step continuity errors : sum local = 1.57568e-10, global = 2.15246e-11, cumulative = 6.37895e-06
smoothSolver: Solving for epsilon, Initial residual = 7.43025e-05, Final residual = 9.33074e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000110682, Final residual = 5.79016e-06, No Iterations 4
ExecutionTime = 52.4 s ClockTime = 53 s
Time = 4.8975
Courant Number mean: 0.113498 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.73114e-05, Final residual = 4.85316e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.92701e-05, Final residual = 9.45924e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000128583, Final residual = 9.94671e-06, No Iterations 9
time step continuity errors : sum local = 1.94935e-09, global = -1.77037e-10, cumulative = 6.37877e-06
GAMG: Solving for p, Initial residual = 0.000100323, Final residual = 8.17646e-07, No Iterations 19
time step continuity errors : sum local = 1.60248e-10, global = 2.2441e-11, cumulative = 6.37879e-06
smoothSolver: Solving for epsilon, Initial residual = 7.38946e-05, Final residual = 9.27594e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000109958, Final residual = 5.74853e-06, No Iterations 4
ExecutionTime = 52.44 s ClockTime = 53 s
Time = 4.9
Courant Number mean: 0.113499 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.72571e-05, Final residual = 4.84002e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.91759e-05, Final residual = 9.43505e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.00012789, Final residual = 9.94796e-06, No Iterations 9
time step continuity errors : sum local = 1.94963e-09, global = -1.78174e-10, cumulative = 6.37861e-06
GAMG: Solving for p, Initial residual = 9.9887e-05, Final residual = 8.33954e-07, No Iterations 19
time step continuity errors : sum local = 1.63447e-10, global = 2.35125e-11, cumulative = 6.37864e-06
smoothSolver: Solving for epsilon, Initial residual = 7.34855e-05, Final residual = 9.22086e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000109235, Final residual = 5.70729e-06, No Iterations 4
ExecutionTime = 52.49 s ClockTime = 53 s
Time = 4.9025
Courant Number mean: 0.113499 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.72026e-05, Final residual = 4.82681e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.90819e-05, Final residual = 9.41063e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000127198, Final residual = 9.94981e-06, No Iterations 9
time step continuity errors : sum local = 1.95003e-09, global = -1.79408e-10, cumulative = 6.37846e-06
GAMG: Solving for p, Initial residual = 9.94528e-05, Final residual = 8.51072e-07, No Iterations 19
time step continuity errors : sum local = 1.66805e-10, global = 2.46316e-11, cumulative = 6.37848e-06
smoothSolver: Solving for epsilon, Initial residual = 7.30755e-05, Final residual = 9.16536e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000108515, Final residual = 5.66612e-06, No Iterations 4
ExecutionTime = 52.52 s ClockTime = 53 s
Time = 4.905
Courant Number mean: 0.1135 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.71481e-05, Final residual = 4.81353e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.89884e-05, Final residual = 9.38611e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000126505, Final residual = 9.95259e-06, No Iterations 9
time step continuity errors : sum local = 1.95061e-09, global = -1.80709e-10, cumulative = 6.3783e-06
GAMG: Solving for p, Initial residual = 9.9032e-05, Final residual = 8.68657e-07, No Iterations 19
time step continuity errors : sum local = 1.70254e-10, global = 2.57839e-11, cumulative = 6.37833e-06
smoothSolver: Solving for epsilon, Initial residual = 7.26651e-05, Final residual = 9.10944e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000107797, Final residual = 5.62502e-06, No Iterations 4
ExecutionTime = 52.55 s ClockTime = 53 s
Time = 4.9075
Courant Number mean: 0.1135 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.70936e-05, Final residual = 4.80015e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.88947e-05, Final residual = 9.36138e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000125818, Final residual = 9.95613e-06, No Iterations 9
time step continuity errors : sum local = 1.95134e-09, global = -1.82075e-10, cumulative = 6.37815e-06
GAMG: Solving for p, Initial residual = 9.86099e-05, Final residual = 8.86606e-07, No Iterations 19
time step continuity errors : sum local = 1.73774e-10, global = 2.69671e-11, cumulative = 6.37817e-06
smoothSolver: Solving for epsilon, Initial residual = 7.2254e-05, Final residual = 9.05319e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000107081, Final residual = 5.584e-06, No Iterations 4
ExecutionTime = 52.59 s ClockTime = 53 s
Time = 4.91
Courant Number mean: 0.113501 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.70391e-05, Final residual = 4.78669e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.88009e-05, Final residual = 9.33647e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000125141, Final residual = 9.95991e-06, No Iterations 9
time step continuity errors : sum local = 1.95211e-09, global = -1.83506e-10, cumulative = 6.37799e-06
GAMG: Solving for p, Initial residual = 9.81867e-05, Final residual = 9.04827e-07, No Iterations 19
time step continuity errors : sum local = 1.77348e-10, global = 2.81767e-11, cumulative = 6.37802e-06
smoothSolver: Solving for epsilon, Initial residual = 7.18427e-05, Final residual = 8.99663e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000106366, Final residual = 5.54305e-06, No Iterations 4
ExecutionTime = 52.62 s ClockTime = 53 s
Time = 4.9125
Courant Number mean: 0.113501 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.69846e-05, Final residual = 4.77316e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.87069e-05, Final residual = 9.3114e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000124464, Final residual = 9.9641e-06, No Iterations 9
time step continuity errors : sum local = 1.95297e-09, global = -1.85002e-10, cumulative = 6.37783e-06
GAMG: Solving for p, Initial residual = 9.7762e-05, Final residual = 9.23381e-07, No Iterations 19
time step continuity errors : sum local = 1.80988e-10, global = 2.94067e-11, cumulative = 6.37786e-06
smoothSolver: Solving for epsilon, Initial residual = 7.14306e-05, Final residual = 8.93978e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000105654, Final residual = 5.50213e-06, No Iterations 4
ExecutionTime = 52.65 s ClockTime = 53 s
Time = 4.915
Courant Number mean: 0.113501 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.693e-05, Final residual = 4.75956e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.86122e-05, Final residual = 9.28611e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000123786, Final residual = 9.96865e-06, No Iterations 9
time step continuity errors : sum local = 1.95389e-09, global = -1.86559e-10, cumulative = 6.37768e-06
GAMG: Solving for p, Initial residual = 9.73356e-05, Final residual = 9.42349e-07, No Iterations 19
time step continuity errors : sum local = 1.84708e-10, global = 3.06509e-11, cumulative = 6.37771e-06
smoothSolver: Solving for epsilon, Initial residual = 7.10189e-05, Final residual = 8.88271e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000104943, Final residual = 5.4606e-06, No Iterations 4
ExecutionTime = 52.67 s ClockTime = 53 s
Time = 4.9175
Courant Number mean: 0.113502 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.68751e-05, Final residual = 4.74589e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.85172e-05, Final residual = 9.26053e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000123094, Final residual = 9.97408e-06, No Iterations 9
time step continuity errors : sum local = 1.95499e-09, global = -1.88191e-10, cumulative = 6.37752e-06
GAMG: Solving for p, Initial residual = 9.69045e-05, Final residual = 9.61572e-07, No Iterations 19
time step continuity errors : sum local = 1.88478e-10, global = 3.1908e-11, cumulative = 6.37755e-06
smoothSolver: Solving for epsilon, Initial residual = 7.06073e-05, Final residual = 8.82539e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000104235, Final residual = 9.97712e-06, No Iterations 3
ExecutionTime = 52.7 s ClockTime = 53 s
Time = 4.92
Courant Number mean: 0.113502 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.68147e-05, Final residual = 4.72986e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.84264e-05, Final residual = 9.23647e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000121134, Final residual = 1.03604e-05, No Iterations 9
time step continuity errors : sum local = 2.03072e-09, global = -2.12418e-10, cumulative = 6.37734e-06
GAMG: Solving for p, Initial residual = 9.66432e-05, Final residual = 8.59255e-07, No Iterations 19
time step continuity errors : sum local = 1.68427e-10, global = 2.58715e-11, cumulative = 6.37736e-06
smoothSolver: Solving for epsilon, Initial residual = 7.0131e-05, Final residual = 8.7522e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000103492, Final residual = 9.90675e-06, No Iterations 3
ExecutionTime = 52.73 s ClockTime = 53 s
Time = 4.9225
Courant Number mean: 0.113503 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.67538e-05, Final residual = 4.71431e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.83235e-05, Final residual = 9.20746e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000120803, Final residual = 1.03501e-05, No Iterations 9
time step continuity errors : sum local = 2.02873e-09, global = -2.12942e-10, cumulative = 6.37715e-06
GAMG: Solving for p, Initial residual = 9.62158e-05, Final residual = 8.77284e-07, No Iterations 19
time step continuity errors : sum local = 1.71962e-10, global = 2.70253e-11, cumulative = 6.37718e-06
smoothSolver: Solving for epsilon, Initial residual = 6.96567e-05, Final residual = 8.6798e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000102758, Final residual = 9.8367e-06, No Iterations 3
ExecutionTime = 52.76 s ClockTime = 53 s
Time = 4.925
Courant Number mean: 0.113503 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.66936e-05, Final residual = 4.69863e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.82277e-05, Final residual = 9.18134e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000119872, Final residual = 1.03532e-05, No Iterations 9
time step continuity errors : sum local = 2.02936e-09, global = -2.15587e-10, cumulative = 6.37696e-06
GAMG: Solving for p, Initial residual = 9.57264e-05, Final residual = 8.94156e-07, No Iterations 19
time step continuity errors : sum local = 1.75271e-10, global = 2.81413e-11, cumulative = 6.37699e-06
smoothSolver: Solving for epsilon, Initial residual = 6.91838e-05, Final residual = 8.60798e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000102034, Final residual = 9.76725e-06, No Iterations 3
ExecutionTime = 52.79 s ClockTime = 53 s
Time = 4.9275
Courant Number mean: 0.113503 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.66338e-05, Final residual = 4.68298e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.81301e-05, Final residual = 9.15422e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000119088, Final residual = 1.03631e-05, No Iterations 9
time step continuity errors : sum local = 2.03133e-09, global = -2.18424e-10, cumulative = 6.37677e-06
GAMG: Solving for p, Initial residual = 9.52538e-05, Final residual = 9.11395e-07, No Iterations 19
time step continuity errors : sum local = 1.78652e-10, global = 2.92678e-11, cumulative = 6.3768e-06
smoothSolver: Solving for epsilon, Initial residual = 6.87124e-05, Final residual = 8.53684e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000101318, Final residual = 9.69799e-06, No Iterations 3
ExecutionTime = 52.82 s ClockTime = 53 s
Time = 4.93
Courant Number mean: 0.113504 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.65742e-05, Final residual = 4.66733e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.8032e-05, Final residual = 9.12682e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000118346, Final residual = 1.03735e-05, No Iterations 9
time step continuity errors : sum local = 2.03339e-09, global = -2.21359e-10, cumulative = 6.37658e-06
GAMG: Solving for p, Initial residual = 9.47846e-05, Final residual = 9.28839e-07, No Iterations 19
time step continuity errors : sum local = 1.82073e-10, global = 3.04058e-11, cumulative = 6.37661e-06
smoothSolver: Solving for epsilon, Initial residual = 6.82428e-05, Final residual = 8.46635e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 0.000100609, Final residual = 9.62909e-06, No Iterations 3
ExecutionTime = 52.85 s ClockTime = 53 s
Time = 4.9325
Courant Number mean: 0.113504 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.65146e-05, Final residual = 4.6517e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.79332e-05, Final residual = 9.09905e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000117637, Final residual = 1.03842e-05, No Iterations 9
time step continuity errors : sum local = 2.03552e-09, global = -2.24386e-10, cumulative = 6.37639e-06
GAMG: Solving for p, Initial residual = 9.43194e-05, Final residual = 9.46516e-07, No Iterations 19
time step continuity errors : sum local = 1.8554e-10, global = 3.1552e-11, cumulative = 6.37642e-06
smoothSolver: Solving for epsilon, Initial residual = 6.77749e-05, Final residual = 8.39651e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.99069e-05, Final residual = 9.56007e-06, No Iterations 3
ExecutionTime = 52.87 s ClockTime = 53 s
Time = 4.935
Courant Number mean: 0.113505 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.64552e-05, Final residual = 4.63609e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.78342e-05, Final residual = 9.07087e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000116938, Final residual = 1.03955e-05, No Iterations 9
time step continuity errors : sum local = 2.03776e-09, global = -2.27499e-10, cumulative = 6.37619e-06
GAMG: Solving for p, Initial residual = 9.38645e-05, Final residual = 9.64298e-07, No Iterations 19
time step continuity errors : sum local = 1.89028e-10, global = 3.27005e-11, cumulative = 6.37622e-06
smoothSolver: Solving for epsilon, Initial residual = 6.73087e-05, Final residual = 8.32729e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.92106e-05, Final residual = 9.49186e-06, No Iterations 3
ExecutionTime = 52.9 s ClockTime = 53 s
Time = 4.9375
Courant Number mean: 0.113505 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.6396e-05, Final residual = 4.62049e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.77348e-05, Final residual = 9.04237e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000116257, Final residual = 1.0408e-05, No Iterations 9
time step continuity errors : sum local = 2.04024e-09, global = -2.30688e-10, cumulative = 6.37599e-06
GAMG: Solving for p, Initial residual = 9.34149e-05, Final residual = 9.82155e-07, No Iterations 19
time step continuity errors : sum local = 1.9253e-10, global = 3.38477e-11, cumulative = 6.37603e-06
smoothSolver: Solving for epsilon, Initial residual = 6.68445e-05, Final residual = 8.25868e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.85203e-05, Final residual = 9.42396e-06, No Iterations 3
ExecutionTime = 52.93 s ClockTime = 53 s
Time = 4.94
Courant Number mean: 0.113505 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.63369e-05, Final residual = 4.60489e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.76349e-05, Final residual = 9.01376e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000115576, Final residual = 1.04209e-05, No Iterations 9
time step continuity errors : sum local = 2.04278e-09, global = -2.33953e-10, cumulative = 6.37579e-06
GAMG: Solving for p, Initial residual = 9.29712e-05, Final residual = 6.78404e-07, No Iterations 20
time step continuity errors : sum local = 1.32988e-10, global = -1.71862e-11, cumulative = 6.37577e-06
smoothSolver: Solving for epsilon, Initial residual = 6.63824e-05, Final residual = 8.19047e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.78356e-05, Final residual = 9.35638e-06, No Iterations 3
ExecutionTime = 52.96 s ClockTime = 53 s
Time = 4.9425
Courant Number mean: 0.113506 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.62783e-05, Final residual = 4.58928e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.75332e-05, Final residual = 8.98404e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000114656, Final residual = 1.03512e-05, No Iterations 9
time step continuity errors : sum local = 2.02914e-09, global = -2.34283e-10, cumulative = 6.37554e-06
GAMG: Solving for p, Initial residual = 9.25805e-05, Final residual = 6.78084e-07, No Iterations 20
time step continuity errors : sum local = 1.32926e-10, global = -1.68571e-11, cumulative = 6.37552e-06
smoothSolver: Solving for epsilon, Initial residual = 6.59231e-05, Final residual = 8.12261e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.7156e-05, Final residual = 9.2891e-06, No Iterations 3
ExecutionTime = 52.98 s ClockTime = 53 s
Time = 4.945
Courant Number mean: 0.113506 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.62192e-05, Final residual = 4.57368e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.7432e-05, Final residual = 8.955e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000114469, Final residual = 1.03955e-05, No Iterations 9
time step continuity errors : sum local = 2.03785e-09, global = -2.38845e-10, cumulative = 6.37528e-06
GAMG: Solving for p, Initial residual = 9.21554e-05, Final residual = 6.78487e-07, No Iterations 20
time step continuity errors : sum local = 1.33006e-10, global = -1.6641e-11, cumulative = 6.37527e-06
smoothSolver: Solving for epsilon, Initial residual = 6.54659e-05, Final residual = 8.05539e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.64812e-05, Final residual = 9.22237e-06, No Iterations 3
ExecutionTime = 53.01 s ClockTime = 53 s
Time = 4.9475
Courant Number mean: 0.113507 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.61602e-05, Final residual = 4.55805e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.7331e-05, Final residual = 8.92588e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000114407, Final residual = 1.10962e-05, No Iterations 9
time step continuity errors : sum local = 2.17524e-09, global = -3.10389e-10, cumulative = 6.37496e-06
GAMG: Solving for p, Initial residual = 9.20238e-05, Final residual = 6.80153e-07, No Iterations 20
time step continuity errors : sum local = 1.33334e-10, global = -1.69201e-11, cumulative = 6.37494e-06
smoothSolver: Solving for epsilon, Initial residual = 6.50106e-05, Final residual = 7.98853e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.58104e-05, Final residual = 9.15489e-06, No Iterations 3
ExecutionTime = 53.04 s ClockTime = 54 s
Time = 4.95
Courant Number mean: 0.113507 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.61008e-05, Final residual = 4.54246e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.72253e-05, Final residual = 8.89457e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000113464, Final residual = 1.10982e-05, No Iterations 9
time step continuity errors : sum local = 2.17564e-09, global = -3.1252e-10, cumulative = 6.37463e-06
GAMG: Solving for p, Initial residual = 9.15878e-05, Final residual = 6.81614e-07, No Iterations 20
time step continuity errors : sum local = 1.33622e-10, global = -1.66824e-11, cumulative = 6.37461e-06
smoothSolver: Solving for epsilon, Initial residual = 6.45572e-05, Final residual = 7.92238e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.51441e-05, Final residual = 9.08864e-06, No Iterations 3
ExecutionTime = 53.06 s ClockTime = 54 s
Time = 4.9525
Courant Number mean: 0.113507 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.6043e-05, Final residual = 4.52681e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.71286e-05, Final residual = 8.86613e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000113494, Final residual = 1.11351e-05, No Iterations 9
time step continuity errors : sum local = 2.18291e-09, global = -3.17704e-10, cumulative = 6.37429e-06
GAMG: Solving for p, Initial residual = 9.1317e-05, Final residual = 6.81966e-07, No Iterations 20
time step continuity errors : sum local = 1.33692e-10, global = -1.64281e-11, cumulative = 6.37428e-06
smoothSolver: Solving for epsilon, Initial residual = 6.41062e-05, Final residual = 7.85695e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.44818e-05, Final residual = 9.02237e-06, No Iterations 3
ExecutionTime = 53.1 s ClockTime = 54 s
Time = 4.955
Courant Number mean: 0.113508 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.59853e-05, Final residual = 4.51114e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.70336e-05, Final residual = 8.83785e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000111597, Final residual = 8.94399e-06, No Iterations 10
time step continuity errors : sum local = 1.75339e-09, global = 2.62331e-10, cumulative = 6.37454e-06
GAMG: Solving for p, Initial residual = 9.06167e-05, Final residual = 8.82135e-07, No Iterations 18
time step continuity errors : sum local = 1.72935e-10, global = -2.27426e-11, cumulative = 6.37452e-06
smoothSolver: Solving for epsilon, Initial residual = 6.36573e-05, Final residual = 7.79175e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.38235e-05, Final residual = 8.9565e-06, No Iterations 3
ExecutionTime = 53.13 s ClockTime = 54 s
Time = 4.9575
Courant Number mean: 0.113508 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.59287e-05, Final residual = 4.49557e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.69097e-05, Final residual = 8.79552e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.00011192, Final residual = 1.09893e-05, No Iterations 9
time step continuity errors : sum local = 2.15437e-09, global = -3.1518e-10, cumulative = 6.3742e-06
GAMG: Solving for p, Initial residual = 9.07616e-05, Final residual = 6.79318e-07, No Iterations 20
time step continuity errors : sum local = 1.33176e-10, global = -1.57195e-11, cumulative = 6.37419e-06
smoothSolver: Solving for epsilon, Initial residual = 6.32111e-05, Final residual = 7.72707e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.31693e-05, Final residual = 8.89091e-06, No Iterations 3
ExecutionTime = 53.16 s ClockTime = 54 s
Time = 4.96
Courant Number mean: 0.113508 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.58699e-05, Final residual = 4.47981e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.68302e-05, Final residual = 8.77688e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000110319, Final residual = 8.81832e-06, No Iterations 10
time step continuity errors : sum local = 1.72879e-09, global = 2.57476e-10, cumulative = 6.37444e-06
GAMG: Solving for p, Initial residual = 8.97765e-05, Final residual = 8.74438e-07, No Iterations 18
time step continuity errors : sum local = 1.71429e-10, global = -2.19172e-11, cumulative = 6.37442e-06
smoothSolver: Solving for epsilon, Initial residual = 6.27669e-05, Final residual = 7.66298e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.25188e-05, Final residual = 8.82556e-06, No Iterations 3
ExecutionTime = 53.18 s ClockTime = 54 s
Time = 4.9625
Courant Number mean: 0.113509 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.58123e-05, Final residual = 4.46419e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.67082e-05, Final residual = 8.73531e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000110562, Final residual = 1.1045e-05, No Iterations 9
time step continuity errors : sum local = 2.16533e-09, global = -3.2521e-10, cumulative = 6.3741e-06
GAMG: Solving for p, Initial residual = 8.9981e-05, Final residual = 6.78538e-07, No Iterations 20
time step continuity errors : sum local = 1.33025e-10, global = -1.51464e-11, cumulative = 6.37408e-06
smoothSolver: Solving for epsilon, Initial residual = 6.23251e-05, Final residual = 7.59929e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.18719e-05, Final residual = 8.76013e-06, No Iterations 3
ExecutionTime = 53.21 s ClockTime = 54 s
Time = 4.965
Courant Number mean: 0.113509 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.57539e-05, Final residual = 4.44842e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.66274e-05, Final residual = 8.71569e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000109093, Final residual = 8.67236e-06, No Iterations 10
time step continuity errors : sum local = 1.70021e-09, global = 2.51538e-10, cumulative = 6.37433e-06
GAMG: Solving for p, Initial residual = 8.89431e-05, Final residual = 8.67119e-07, No Iterations 18
time step continuity errors : sum local = 1.69997e-10, global = -2.10504e-11, cumulative = 6.37431e-06
smoothSolver: Solving for epsilon, Initial residual = 6.18855e-05, Final residual = 7.53577e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.12288e-05, Final residual = 8.6953e-06, No Iterations 3
ExecutionTime = 53.24 s ClockTime = 54 s
Time = 4.9675
Courant Number mean: 0.113509 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.56963e-05, Final residual = 4.43277e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.65053e-05, Final residual = 8.67422e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000109305, Final residual = 8.57247e-06, No Iterations 10
time step continuity errors : sum local = 1.68064e-09, global = 2.48883e-10, cumulative = 6.37456e-06
GAMG: Solving for p, Initial residual = 8.90101e-05, Final residual = 8.29696e-07, No Iterations 18
time step continuity errors : sum local = 1.62662e-10, global = -1.97494e-11, cumulative = 6.37454e-06
smoothSolver: Solving for epsilon, Initial residual = 6.14482e-05, Final residual = 7.47309e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 9.05897e-05, Final residual = 8.63074e-06, No Iterations 3
ExecutionTime = 53.27 s ClockTime = 54 s
Time = 4.97
Courant Number mean: 0.11351 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.56397e-05, Final residual = 4.41706e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.64018e-05, Final residual = 8.64227e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000108688, Final residual = 8.52776e-06, No Iterations 10
time step continuity errors : sum local = 1.67189e-09, global = 2.46529e-10, cumulative = 6.37479e-06
GAMG: Solving for p, Initial residual = 8.86257e-05, Final residual = 8.2407e-07, No Iterations 18
time step continuity errors : sum local = 1.6156e-10, global = -1.92935e-11, cumulative = 6.37477e-06
smoothSolver: Solving for epsilon, Initial residual = 6.10133e-05, Final residual = 7.41055e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.99544e-05, Final residual = 8.56643e-06, No Iterations 3
ExecutionTime = 53.29 s ClockTime = 54 s
Time = 4.9725
Courant Number mean: 0.11351 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.5582e-05, Final residual = 4.40132e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.63003e-05, Final residual = 8.61153e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000108044, Final residual = 8.44662e-06, No Iterations 10
time step continuity errors : sum local = 1.656e-09, global = 2.43186e-10, cumulative = 6.37501e-06
GAMG: Solving for p, Initial residual = 8.81945e-05, Final residual = 8.18468e-07, No Iterations 18
time step continuity errors : sum local = 1.60463e-10, global = -1.88058e-11, cumulative = 6.37499e-06
smoothSolver: Solving for epsilon, Initial residual = 6.05805e-05, Final residual = 7.34837e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.93226e-05, Final residual = 8.50221e-06, No Iterations 3
ExecutionTime = 53.32 s ClockTime = 54 s
Time = 4.975
Courant Number mean: 0.113511 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.55247e-05, Final residual = 4.38557e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.6198e-05, Final residual = 8.58026e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000107435, Final residual = 8.37099e-06, No Iterations 10
time step continuity errors : sum local = 1.64119e-09, global = 2.39812e-10, cumulative = 6.37523e-06
GAMG: Solving for p, Initial residual = 8.77807e-05, Final residual = 8.12785e-07, No Iterations 18
time step continuity errors : sum local = 1.59351e-10, global = -1.83268e-11, cumulative = 6.37521e-06
smoothSolver: Solving for epsilon, Initial residual = 6.01502e-05, Final residual = 7.28653e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.86943e-05, Final residual = 8.43857e-06, No Iterations 3
ExecutionTime = 53.35 s ClockTime = 54 s
Time = 4.9775
Courant Number mean: 0.113511 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.54673e-05, Final residual = 4.36981e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.60958e-05, Final residual = 8.54879e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000106829, Final residual = 8.29511e-06, No Iterations 10
time step continuity errors : sum local = 1.62633e-09, global = 2.36374e-10, cumulative = 6.37545e-06
GAMG: Solving for p, Initial residual = 8.7369e-05, Final residual = 8.06815e-07, No Iterations 18
time step continuity errors : sum local = 1.58181e-10, global = -1.78423e-11, cumulative = 6.37543e-06
smoothSolver: Solving for epsilon, Initial residual = 5.97219e-05, Final residual = 7.22503e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.80692e-05, Final residual = 8.37502e-06, No Iterations 3
ExecutionTime = 53.38 s ClockTime = 54 s
Time = 4.98
Courant Number mean: 0.113511 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.541e-05, Final residual = 4.35402e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.59937e-05, Final residual = 8.51707e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000106179, Final residual = 8.21896e-06, No Iterations 10
time step continuity errors : sum local = 1.61142e-09, global = 2.32822e-10, cumulative = 6.37567e-06
GAMG: Solving for p, Initial residual = 8.69631e-05, Final residual = 8.00348e-07, No Iterations 18
time step continuity errors : sum local = 1.56915e-10, global = -1.73571e-11, cumulative = 6.37565e-06
smoothSolver: Solving for epsilon, Initial residual = 5.92957e-05, Final residual = 7.16388e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.74471e-05, Final residual = 8.31172e-06, No Iterations 3
ExecutionTime = 53.4 s ClockTime = 54 s
Time = 4.9825
Courant Number mean: 0.113512 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.53528e-05, Final residual = 4.33822e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.58919e-05, Final residual = 8.48524e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000105606, Final residual = 8.14204e-06, No Iterations 10
time step continuity errors : sum local = 1.59636e-09, global = 2.29178e-10, cumulative = 6.37588e-06
GAMG: Solving for p, Initial residual = 8.65611e-05, Final residual = 7.93303e-07, No Iterations 18
time step continuity errors : sum local = 1.55535e-10, global = -1.6872e-11, cumulative = 6.37586e-06
smoothSolver: Solving for epsilon, Initial residual = 5.88718e-05, Final residual = 7.10309e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.68281e-05, Final residual = 8.24867e-06, No Iterations 3
ExecutionTime = 53.43 s ClockTime = 54 s
Time = 4.985
Courant Number mean: 0.113512 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.52958e-05, Final residual = 4.3224e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.579e-05, Final residual = 8.45331e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000105017, Final residual = 8.06481e-06, No Iterations 10
time step continuity errors : sum local = 1.58123e-09, global = 2.2544e-10, cumulative = 6.37609e-06
GAMG: Solving for p, Initial residual = 8.6162e-05, Final residual = 7.8566e-07, No Iterations 18
time step continuity errors : sum local = 1.54037e-10, global = -1.63885e-11, cumulative = 6.37607e-06
smoothSolver: Solving for epsilon, Initial residual = 5.84505e-05, Final residual = 7.04262e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.62127e-05, Final residual = 8.18586e-06, No Iterations 3
ExecutionTime = 53.45 s ClockTime = 54 s
Time = 4.9875
Courant Number mean: 0.113512 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.52389e-05, Final residual = 4.30655e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.56879e-05, Final residual = 8.42117e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.00010443, Final residual = 7.98679e-06, No Iterations 10
time step continuity errors : sum local = 1.56595e-09, global = 2.21613e-10, cumulative = 6.37629e-06
GAMG: Solving for p, Initial residual = 8.57668e-05, Final residual = 7.7738e-07, No Iterations 18
time step continuity errors : sum local = 1.52415e-10, global = -1.59079e-11, cumulative = 6.37628e-06
smoothSolver: Solving for epsilon, Initial residual = 5.80314e-05, Final residual = 6.98249e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.56008e-05, Final residual = 8.12329e-06, No Iterations 3
ExecutionTime = 53.48 s ClockTime = 54 s
Time = 4.99
Courant Number mean: 0.113513 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.5182e-05, Final residual = 4.29069e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.55855e-05, Final residual = 8.3888e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000103847, Final residual = 7.90799e-06, No Iterations 10
time step continuity errors : sum local = 1.55051e-09, global = 2.177e-10, cumulative = 6.37649e-06
GAMG: Solving for p, Initial residual = 8.53745e-05, Final residual = 7.68385e-07, No Iterations 18
time step continuity errors : sum local = 1.50653e-10, global = -1.54314e-11, cumulative = 6.37648e-06
smoothSolver: Solving for epsilon, Initial residual = 5.76145e-05, Final residual = 6.92266e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.49921e-05, Final residual = 8.06096e-06, No Iterations 3
ExecutionTime = 53.5 s ClockTime = 54 s
Time = 4.9925
Courant Number mean: 0.113513 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.51251e-05, Final residual = 4.27481e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.54831e-05, Final residual = 8.35626e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000103265, Final residual = 7.83009e-06, No Iterations 10
time step continuity errors : sum local = 1.53526e-09, global = 2.13708e-10, cumulative = 6.37669e-06
GAMG: Solving for p, Initial residual = 8.49854e-05, Final residual = 7.58637e-07, No Iterations 18
time step continuity errors : sum local = 1.48743e-10, global = -1.496e-11, cumulative = 6.37668e-06
smoothSolver: Solving for epsilon, Initial residual = 5.72002e-05, Final residual = 6.86314e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.43865e-05, Final residual = 7.99898e-06, No Iterations 3
ExecutionTime = 53.53 s ClockTime = 54 s
Time = 4.995
Courant Number mean: 0.113513 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.50684e-05, Final residual = 4.25891e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.53804e-05, Final residual = 8.32371e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000102689, Final residual = 7.75347e-06, No Iterations 10
time step continuity errors : sum local = 1.52025e-09, global = 2.09641e-10, cumulative = 6.37689e-06
GAMG: Solving for p, Initial residual = 8.45995e-05, Final residual = 7.481e-07, No Iterations 18
time step continuity errors : sum local = 1.46678e-10, global = -1.44942e-11, cumulative = 6.37687e-06
smoothSolver: Solving for epsilon, Initial residual = 5.6788e-05, Final residual = 6.80391e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.37839e-05, Final residual = 7.93711e-06, No Iterations 3
ExecutionTime = 53.56 s ClockTime = 54 s
Time = 4.9975
Courant Number mean: 0.113513 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.50117e-05, Final residual = 4.243e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.52775e-05, Final residual = 8.29107e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000102121, Final residual = 7.67631e-06, No Iterations 10
time step continuity errors : sum local = 1.50514e-09, global = 2.05505e-10, cumulative = 6.37708e-06
GAMG: Solving for p, Initial residual = 8.4219e-05, Final residual = 7.36747e-07, No Iterations 18
time step continuity errors : sum local = 1.44453e-10, global = -1.40349e-11, cumulative = 6.37706e-06
smoothSolver: Solving for epsilon, Initial residual = 5.63783e-05, Final residual = 6.74508e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.31842e-05, Final residual = 7.87548e-06, No Iterations 3
ExecutionTime = 53.59 s ClockTime = 54 s
Time = 5
Courant Number mean: 0.113514 max: 0.616699
smoothSolver: Solving for Ux, Initial residual = 1.49551e-05, Final residual = 4.22706e-06, No Iterations 1
smoothSolver: Solving for Uy, Initial residual = 2.51744e-05, Final residual = 8.25824e-06, No Iterations 1
GAMG: Solving for p, Initial residual = 0.000101557, Final residual = 7.59937e-06, No Iterations 10
time step continuity errors : sum local = 1.49006e-09, global = 2.01307e-10, cumulative = 6.37726e-06
GAMG: Solving for p, Initial residual = 8.38428e-05, Final residual = 7.24641e-07, No Iterations 18
time step continuity errors : sum local = 1.4208e-10, global = -1.35826e-11, cumulative = 6.37725e-06
smoothSolver: Solving for epsilon, Initial residual = 5.59711e-05, Final residual = 6.68631e-06, No Iterations 2
smoothSolver: Solving for k, Initial residual = 8.2588e-05, Final residual = 7.81408e-06, No Iterations 3
ExecutionTime = 53.64 s ClockTime = 54 s
End
|
D
|
module android.java.android.media.audiofx.DynamicsProcessing_Config_Builder;
public import android.java.android.media.audiofx.DynamicsProcessing_Config_Builder_d_interface;
import arsd.jni : ImportExportImpl;
mixin ImportExportImpl!DynamicsProcessing_Config_Builder;
import import0 = android.java.android.media.audiofx.DynamicsProcessing_Config_Builder;
import import5 = android.java.android.media.audiofx.DynamicsProcessing_Config;
import import6 = android.java.java.lang.Class;
|
D
|
// PERMUTE_ARGS: -inline -O -property
// Test operator overloading
extern (C) int printf(const(char*) fmt, ...);
template Seq(T...){ alias T Seq; }
bool thrown(E, T)(lazy T val)
{
try { val(); return false; }
catch (E e) { return true; }
}
/**************************************/
class A
{
string opUnary(string s)()
{
printf("A.opUnary!(%.*s)\n", s.length, s.ptr);
return s;
}
}
void test1()
{
auto a = new A();
+a;
-a;
~a;
*a;
++a;
--a;
auto x = a++;
assert(x == a);
auto y = a--;
assert(y == a);
}
/**************************************/
class A2
{
T opCast(T)()
{
auto s = T.stringof;
printf("A.opCast!(%.*s)\n", s.length, s.ptr);
return T.init;
}
}
void test2()
{
auto a = new A2();
auto x = cast(int)a;
assert(x == 0);
auto y = cast(char)a;
assert(y == char.init);
}
/**************************************/
struct A3
{
int opBinary(string s)(int i)
{
printf("A.opBinary!(%.*s)\n", s.length, s.ptr);
return 0;
}
int opBinaryRight(string s)(int i) if (s == "/" || s == "*")
{
printf("A.opBinaryRight!(%.*s)\n", s.length, s.ptr);
return 0;
}
T opCast(T)()
{
auto s = T.stringof;
printf("A.opCast!(%.*s)\n", s.length, s.ptr);
return T.init;
}
}
void test3()
{
A3 a;
a + 3;
4 * a;
4 / a;
a & 5;
}
/**************************************/
struct A4
{
int opUnary(string s)()
{
printf("A.opUnary!(%.*s)\n", s.length, s.ptr);
return 0;
}
T opCast(T)()
{
auto s = T.stringof;
printf("A.opCast!(%.*s)\n", s.length, s.ptr);
return T.init;
}
}
void test4()
{
A4 a;
if (a)
int x = 3;
if (!a)
int x = 3;
if (!!a)
int x = 3;
}
/**************************************/
class A5
{
override bool opEquals(Object o)
{
printf("A.opEquals!(%p)\n", o);
return 1;
}
int opUnary(string s)()
{
printf("A.opUnary!(%.*s)\n", s.length, s.ptr);
return 0;
}
T opCast(T)()
{
auto s = T.stringof;
printf("A.opCast!(%.*s)\n", s.length, s.ptr);
return T.init;
}
}
class B5 : A5
{
override bool opEquals(Object o)
{
printf("B.opEquals!(%p)\n", o);
return 1;
}
}
void test5()
{
A5 a = new A5();
A5 a2 = new A5();
B5 b = new B5();
A n = null;
if (a == a)
int x = 3;
if (a == a2)
int x = 3;
if (a == b)
int x = 3;
if (a == n)
int x = 3;
if (n == a)
int x = 3;
if (n == n)
int x = 3;
}
/**************************************/
struct S6
{
const bool opEquals(ref const S6 b)
{
printf("S.opEquals(S %p)\n", &b);
return true;
}
const bool opEquals(ref const T6 b)
{
printf("S.opEquals(T %p)\n", &b);
return true;
}
}
struct T6
{
const bool opEquals(ref const T6 b)
{
printf("T.opEquals(T %p)\n", &b);
return true;
}
/+
const bool opEquals(ref const S6 b)
{
printf("T.opEquals(S %p)\n", &b);
return true;
}
+/
}
void test6()
{
S6 s1;
S6 s2;
if (s1 == s2)
int x = 3;
T6 t;
if (s1 == t)
int x = 3;
if (t == s2)
int x = 3;
}
/**************************************/
struct S7
{
const int opCmp(ref const S7 b)
{
printf("S.opCmp(S %p)\n", &b);
return -1;
}
const int opCmp(ref const T7 b)
{
printf("S.opCmp(T %p)\n", &b);
return -1;
}
}
struct T7
{
const int opCmp(ref const T7 b)
{
printf("T.opCmp(T %p)\n", &b);
return -1;
}
/+
const int opCmp(ref const S7 b)
{
printf("T.opCmp(S %p)\n", &b);
return -1;
}
+/
}
void test7()
{
S7 s1;
S7 s2;
if (s1 < s2)
int x = 3;
T7 t;
if (s1 < t)
int x = 3;
if (t < s2)
int x = 3;
}
/**************************************/
struct A8
{
int opUnary(string s)()
{
printf("A.opUnary!(%.*s)\n", s.length, s.ptr);
return 0;
}
int opIndexUnary(string s, T)(T i)
{
printf("A.opIndexUnary!(%.*s)(%d)\n", s.length, s.ptr, i);
return 0;
}
int opIndexUnary(string s, T)(T i, T j)
{
printf("A.opIndexUnary!(%.*s)(%d, %d)\n", s.length, s.ptr, i, j);
return 0;
}
int opSliceUnary(string s)()
{
printf("A.opSliceUnary!(%.*s)()\n", s.length, s.ptr);
return 0;
}
int opSliceUnary(string s, T)(T i, T j)
{
printf("A.opSliceUnary!(%.*s)(%d, %d)\n", s.length, s.ptr, i, j);
return 0;
}
}
void test8()
{
A8 a;
-a;
-a[3];
-a[3, 4];
-a[];
-a[5 .. 6];
--a[3];
}
/**************************************/
struct A9
{
int opOpAssign(string s)(int i)
{
printf("A.opOpAssign!(%.*s)\n", s.length, s.ptr);
return 0;
}
int opIndexOpAssign(string s, T)(int v, T i)
{
printf("A.opIndexOpAssign!(%.*s)(%d, %d)\n", s.length, s.ptr, v, i);
return 0;
}
int opIndexOpAssign(string s, T)(int v, T i, T j)
{
printf("A.opIndexOpAssign!(%.*s)(%d, %d, %d)\n", s.length, s.ptr, v, i, j);
return 0;
}
int opSliceOpAssign(string s)(int v)
{
printf("A.opSliceOpAssign!(%.*s)(%d)\n", s.length, s.ptr, v);
return 0;
}
int opSliceOpAssign(string s, T)(int v, T i, T j)
{
printf("A.opSliceOpAssign!(%.*s)(%d, %d, %d)\n", s.length, s.ptr, v, i, j);
return 0;
}
}
void test9()
{
A9 a;
a += 8;
a -= 8;
a *= 8;
a /= 8;
a %= 8;
a &= 8;
a |= 8;
a ^= 8;
a <<= 8;
a >>= 8;
a >>>= 8;
a ~= 8;
a ^^= 8;
a[3] += 8;
a[3] -= 8;
a[3] *= 8;
a[3] /= 8;
a[3] %= 8;
a[3] &= 8;
a[3] |= 8;
a[3] ^= 8;
a[3] <<= 8;
a[3] >>= 8;
a[3] >>>= 8;
a[3] ~= 8;
a[3] ^^= 8;
a[3, 4] += 8;
a[] += 8;
a[5 .. 6] += 8;
}
/**************************************/
struct BigInt
{
int opEquals(T)(T n) const
{
return 1;
}
int opEquals(T:int)(T n) const
{
return 1;
}
int opEquals(T:const(BigInt))(T n) const
{
return 1;
}
}
int decimal(BigInt b, const BigInt c)
{
while (b != c) {
}
return 1;
}
/**************************************/
struct Foo10
{
int opUnary(string op)() { return 1; }
}
void test10()
{
Foo10 foo;
foo++;
}
/**************************************/
struct S4913
{
bool opCast(T : bool)() { return true; }
}
int bug4913()
{
if (S4913 s = S4913()) { return 83; }
return 9;
}
static assert(bug4913() == 83);
/**************************************/
// 5551
struct Foo11 {
Foo11 opUnary(string op:"++")() {
return this;
}
Foo11 opBinary(string op)(int y) {
return this;
}
}
void test11()
{
auto f = Foo11();
f++;
}
/**************************************/
// 4099
struct X4099
{
int x;
alias x this;
typeof(this) opUnary (string operator) ()
{
printf("operator called\n");
return this;
}
}
void test4099()
{
X4099 x;
X4099 r1 = ++x; //operator called
X4099 r2 = x++; //BUG! (alias this used. returns int)
}
/**************************************/
void test12()
{
static int opeq;
// xopEquals OK
static struct S1a { const bool opEquals( const typeof(this) rhs) { ++opeq; return false; } }
static struct S1b { const bool opEquals(ref const typeof(this) rhs) { ++opeq; return false; } }
static struct S1c { const bool opEquals( typeof(this) rhs) { ++opeq; return false; } }
// xopEquals NG
static struct S2a { bool opEquals( typeof(this) rhs) { ++opeq; return false; } }
foreach (S; Seq!(S1a, S1b, S1c))
{
S s;
opeq = 0;
assert(s != s); // call opEquals directly
assert(!typeid(S).equals(&s, &s)); // -> xopEquals (-> __xopEquals) -> opEquals
assert(opeq == 2);
}
foreach (S; Seq!(S2a))
{
S s;
opeq = 0;
assert(s != s);
assert(thrown!Error(!typeid(S).equals(&s, &s)));
// Error("notImplemented") thrown
assert(opeq == 1);
}
}
/**************************************/
void test13()
{
static int opeq;
struct X
{
const bool opEquals(const X){ ++opeq; return false; }
}
struct S
{
X x;
}
S makeS(){ return S(); }
S s;
opeq = 0;
assert(s != s);
assert(makeS() != s);
assert(s != makeS());
assert(makeS() != makeS());
assert(opeq == 4);
// built-in opEquals == const bool opEquals(const S rhs);
assert(s != s);
assert(opeq == 5);
// xopEquals
assert(!typeid(S).equals(&s, &s));
assert(opeq == 6);
}
/**************************************/
void test14()
{
static int opeq;
struct S
{
const bool opEquals(T)(const T rhs) { ++opeq; return false; }
}
S makeS(){ return S(); }
S s;
opeq = 0;
assert(s != s);
assert(makeS() != s);
assert(s != makeS());
assert(makeS() != makeS());
assert(opeq == 4);
// xopEquals (-> __xxopEquals) -> template opEquals
assert(!typeid(S).equals(&s, &s));
assert(opeq == 5);
}
/**************************************/
void test15()
{
struct S
{
const bool opEquals(T)(const(T) rhs)
if (!is(T == S))
{ return false; }
@disable const bool opEquals(T)(const(T) rhs)
if (is(T == S))
{ return false; }
}
S makeS(){ return S(); }
S s;
static assert(!__traits(compiles, s != s));
static assert(!__traits(compiles, makeS() != s));
static assert(!__traits(compiles, s != makeS()));
static assert(!__traits(compiles, makeS() != makeS()));
// xopEquals (-> __xxopEquals) -> Error thrown
assert(thrown!Error(!typeid(S).equals(&s, &s)));
}
/**************************************/
void test16()
{
struct X
{
int n;
const bool opEquals(T)(T t)
{
return false;
}
}
struct S
{
X x;
}
S s1, s2;
assert(s1 != s2);
// field template opEquals should call
}
/**************************************/
void test17()
{
static int opeq = 0;
struct S
{
bool opEquals(ref S rhs) { ++opeq; return false; }
}
S[] sa1 = new S[3];
S[] sa2 = new S[3];
assert(sa1 != sa2); // isn't used TypeInfo.equals
assert(opeq == 1);
const(S)[] csa = new const(S)[3];
static assert(!__traits(compiles, csa == sa1));
static assert(!__traits(compiles, sa1 == csa));
static assert(!__traits(compiles, csa == csa));
}
/**************************************/
// 3789
bool test3789()
{
static struct Float
{
double x;
}
Float f;
assert(f.x != f.x); // NaN != NaN
assert(f != f);
static struct Array
{
int[] x;
}
Array a1 = Array([1,2,3].dup);
Array a2 = Array([1,2,3].dup);
if (!__ctfe)
{ // Currently doesn't work this in CTFE - may or may not a bug.
assert(a1.x !is a2.x);
}
assert(a1.x == a2.x);
assert(a1 == a2);
static struct AA
{
int[int] x;
}
AA aa1 = AA([1:1,2:2,3:3]);
AA aa2 = AA([1:1,2:2,3:3]);
if (!__ctfe)
{ // Currently doesn't work this in CTFE - may or may not a bug.
assert(aa1.x !is aa2.x);
}
if (!__ctfe)
{ // This is definitely a bug. Should work in CTFE.
assert(aa1.x == aa2.x);
assert(aa1 == aa2);
}
if (!__ctfe)
{ // Currently union operation is not supported in CTFE.
union U1
{
double x;
}
static struct UnionA
{
int[] a;
U1 u;
}
auto ua1 = UnionA([1,2,3]);
auto ua2 = UnionA([1,2,3]);
assert(ua1.u.x is ua2.u.x);
assert(ua1.u.x != ua2.u.x);
assert(ua1 == ua2);
ua1.u.x = 1.0;
ua2.u.x = 1.0;
assert(ua1.u.x is ua2.u.x);
assert(ua1.u.x == ua2.u.x);
assert(ua1 == ua2);
ua1.u.x = double.nan;
assert(ua1.u.x !is ua2.u.x);
assert(ua1.u.x != ua2.u.x);
assert(ua1 != ua2);
union U2
{
int[] a;
}
static struct UnionB
{
double x;
U2 u;
}
auto ub1 = UnionB(1.0);
auto ub2 = UnionB(1.0);
assert(ub1 == ub2);
ub1.u.a = [1,2,3].dup;
ub2.u.a = [1,2,3].dup;
assert(ub1.u.a !is ub2.u.a);
assert(ub1.u.a == ub2.u.a);
assert(ub1 != ub2);
ub2.u.a = ub1.u.a;
assert(ub1.u.a is ub2.u.a);
assert(ub1.u.a == ub2.u.a);
assert(ub1 == ub2);
}
if (!__ctfe)
{ // This is definitely a bug. Should work in CTFE.
static struct Class
{
Object x;
}
static class X
{
override bool opEquals(Object o){ return true; }
}
Class c1a = Class(new Object());
Class c2a = Class(new Object());
assert(c1a.x !is c2a.x);
assert(c1a.x != c2a.x);
assert(c1a != c2a); // Pass, Object.opEquals works like bitwise compare
Class c1b = Class(new X());
Class c2b = Class(new X());
assert(c1b.x !is c2b.x);
assert(c1b.x == c2b.x);
assert(c1b == c2b); // Fails, should pass
}
return true;
}
static assert(test3789());
/**************************************/
// 10037
struct S10037
{
bool opEquals(ref const S10037) { assert(0); }
}
struct T10037
{
S10037 s;
// Compiler should not generate 'opEquals' here implicitly:
}
struct Sub10037(TL...)
{
TL data;
int value;
alias value this;
}
void test10037()
{
S10037 s;
T10037 t;
static assert( __traits(hasMember, S10037, "opEquals"));
static assert(!__traits(hasMember, T10037, "opEquals"));
assert(thrown!Error(s == s));
assert(thrown!Error(t == t));
Sub10037!(S10037) lhs;
Sub10037!(S10037) rhs;
static assert(!__traits(hasMember, Sub10037!(S10037), "opEquals"));
assert(lhs == rhs); // lowered to: lhs.value == rhs.value
}
/**************************************/
// 5810
struct Bug5810
{
void opUnary(string op)() {}
}
struct Foo5810
{
Bug5810 x;
void bar() { x++; }
}
/**************************************/
// 6798
struct Tuple6798(T...)
{
T field;
alias field this;
bool opEquals(Tuple6798 rhs)
{
foreach (i, _; T)
{
if (this[i] != rhs[i])
return false;
}
return true;
}
}
auto tuple6798(T...)(T args)
{
return Tuple6798!T(args);
}
int test6798a()
{
//import std.typecons;
alias tuple6798 tuple;
static struct S1
{
auto opDollar(size_t dim)()
{
return 99;
}
auto opSlice(int dim)(int lwr, int upr)
{
return [dim, lwr, upr];
}
auto opIndex(A...)(A indices)
{
return tuple(" []", indices);
}
auto opIndexUnary(string op, A...)(A indices)
{
return tuple(op~"[]", indices);
}
auto opIndexAssign(A...)(string s, A indices)
{
return tuple("[] =", s, indices);
}
auto opIndexOpAssign(string op, A...)(string s, A indices)
{
return tuple("[]"~op~"=", s, indices);
}
}
S1 s1;
assert( s1[] == tuple(" []"));
assert( s1[10] == tuple(" []", 10));
assert( s1[10, 20] == tuple(" []", 10, 20));
assert( s1[10..20] == tuple(" []", [0, 10, 20]));
assert(+s1[] == tuple("+[]"));
assert(-s1[10] == tuple("-[]", 10));
assert(*s1[10, 20] == tuple("*[]", 10, 20));
assert(~s1[10..20] == tuple("~[]", [0, 10, 20]));
assert((s1[] ="x") == tuple("[] =", "x"));
assert((s1[10] ="x") == tuple("[] =", "x", 10));
assert((s1[10, 20] ="x") == tuple("[] =", "x", 10, 20));
assert((s1[10..20] ="x") == tuple("[] =", "x", [0, 10, 20]));
assert((s1[] +="x") == tuple("[]+=", "x"));
assert((s1[10] -="x") == tuple("[]-=", "x", 10));
assert((s1[10, 20]*="x") == tuple("[]*=", "x", 10, 20));
assert((s1[10..20]~="x") == tuple("[]~=", "x", [0, 10, 20]));
assert( s1[20..30, 10] == tuple(" []", [0, 20, 30], 10));
assert( s1[10, 10..$, $-4, $..2] == tuple(" []", 10, [1,10,99], 99-4, [3,99,2]));
assert(+s1[20..30, 10] == tuple("+[]", [0, 20, 30], 10));
assert(-s1[10, 10..$, $-4, $..2] == tuple("-[]", 10, [1,10,99], 99-4, [3,99,2]));
assert((s1[20..30, 10] ="x") == tuple("[] =", "x", [0, 20, 30], 10));
assert((s1[10, 10..$, $-4, $..2] ="x") == tuple("[] =", "x", 10, [1,10,99], 99-4, [3,99,2]));
assert((s1[20..30, 10] +="x") == tuple("[]+=", "x", [0, 20, 30], 10));
assert((s1[10, 10..$, $-4, $..2]-="x") == tuple("[]-=", "x", 10, [1,10,99], 99-4, [3,99,2]));
// opIndex exist, but opSlice for multi-dimensional doesn't.
static struct S2
{
auto opSlice(size_t dim)() { return [dim]; }
auto opSlice()(size_t lwr, size_t upr) { return [lwr, upr]; }
auto opIndex(A...)(A indices){ return [[indices]]; }
}
S2 s2;
static assert(!__traits(compiles, s2[] ));
assert(s2[1] == [[1]]);
assert(s2[1, 2] == [[1, 2]]);
assert(s2[1..2] == [1, 2]);
static assert(!__traits(compiles, s2[1, 2..3] ));
static assert(!__traits(compiles, s2[1..2, 2..3] ));
// opSlice for multi-dimensional exists, but opIndex for that doesn't.
static struct S3
{
auto opSlice(size_t dim)(size_t lwr, size_t upr) { return [lwr, upr]; }
auto opIndex(size_t n){ return [[n]]; }
auto opIndex(size_t n, size_t m){ return [[n, m]]; }
}
S3 s3;
static assert(!__traits(compiles, s3[] ));
assert(s3[1] == [[1]]);
assert(s3[1, 2] == [[1, 2]]);
static assert(!__traits(compiles, s3[1..2] ));
static assert(!__traits(compiles, s3[1, 2..3] ));
static assert(!__traits(compiles, s3[1..2, 2..3] ));
return 0;
}
int test6798b()
{
static struct Typedef(T)
{
private T Typedef_payload = T.init;
alias a = Typedef_payload;
auto ref opIndex(this X, D...)(auto ref D i) { return a[i]; }
auto ref opSlice(this X )() { return a[]; }
auto ref opSlice(this X, B, E)(auto ref B b, auto ref E e)
{
assert(b == 0 && e == 3);
return a[b..e];
}
template opDispatch(string name)
{
// field or property function
@property auto ref opDispatch(this X)() { return mixin("a."~name); }
@property auto ref opDispatch(this X, V)(auto ref V v) { return mixin("a."~name~" = v"); }
}
static if (is(typeof(a) : E[], E))
{
auto opDollar() const { return a.length; }
}
}
Typedef!(int[]) dollar2;
dollar2.length = 3;
assert(dollar2.Typedef_payload.length == 3);
assert(dollar2[0 .. $] is dollar2[0 .. 3]);
return 0;
}
int test6798c()
{
alias T = Tuple6798!(int, int);
auto n = T[].init;
static assert(is(typeof(n[0]) == Tuple6798!(int, int)));
return 0;
}
void test6798()
{
static assert(test6798a() == 0); // CTFE check
test6798a();
static assert(test6798b() == 0);
test6798b();
static assert(test6798c() == 0);
test6798c();
}
/**************************************/
// 12382
struct S12382
{
size_t opDollar() { return 0; }
size_t opIndex(size_t) { return 0; }
}
S12382 func12382() { return S12382(); }
static assert(S12382.init[$] == 0);
static assert(func12382()[$] == 0);
enum e12382a = S12382.init[$];
enum e12382b = func12382()[$];
static v12382a = S12382.init[$];
static v12382b = func12382()[$];
void test12382()
{
static assert(S12382.init[$] == 0);
static assert(func12382()[$] == 0);
enum e12382a = S12382.init[$];
enum e12382b = func12382()[$];
static v12382a = S12382.init[$];
static v12382b = func12382()[$];
}
/**************************************/
// 12904
struct S12904
{
void opIndexAssign(U, A...)(U value, A args)
{
static assert(0);
}
void opSliceAssign(int n)
{
assert(n == 10);
}
size_t opDollar(size_t dim)()
{
return 7;
}
int opSlice(size_t dim)(size_t, size_t to)
{
assert(to == 7);
return 1;
}
int opIndex(int i1, int i2)
{
assert(i1 == 1 && i2 == 1);
return 10;
}
}
void test12904()
{
S12904 s;
s[] = s[0..$, 1];
s[] = s[0..$, 0..$];
}
/**************************************/
// 7641
mixin template Proxy7641(alias a)
{
auto ref opBinaryRight(string op, B)(auto ref B b)
{
return mixin("b "~op~" a");
}
}
struct Typedef7641(T)
{
private T Typedef_payload;
this(T init)
{
Typedef_payload = init;
}
mixin Proxy7641!Typedef_payload;
}
void test7641()
{
class C {}
C c1 = new C();
auto a = Typedef7641!C(c1);
static assert(!__traits(compiles, { C c2 = a; }));
}
/**************************************/
// 8434
void test8434()
{
static class Vector2D(T)
{
T x, y;
this(T x, T y) {
this.x = x;
this.y = y;
}
U opCast(U)() const { assert(0); }
}
alias Vector2D!(short) Vector2s;
alias Vector2D!(float) Vector2f;
Vector2s vs1 = new Vector2s(42, 23);
Vector2s vs2 = new Vector2s(42, 23);
assert(vs1 != vs2);
}
/**************************************/
void test18()
{
// one dimensional indexing
static struct IndexExp
{
int[] opIndex(int a)
{
return [a];
}
int[] opIndexUnary(string op)(int a)
{
return [a];
}
int[] opIndexAssign(int val, int a)
{
return [val, a];
}
int[] opIndexOpAssign(string op)(int val, int a)
{
return [val, a];
}
int opDollar()
{
return 8;
}
}
IndexExp index;
// opIndex
assert(index[8] == [8]);
assert(index[$] == [8]);
assert(index[$-1] == [7]);
assert(index[$-$/2] == [4]);
// opIndexUnary
assert(-index[8] == [8]);
assert(-index[$] == [8]);
assert(-index[$-1] == [7]);
assert(-index[$-$/2] == [4]);
// opIndexAssign
assert((index[8] = 2) == [2, 8]);
assert((index[$] = 2) == [2, 8]);
assert((index[$-1] = 2) == [2, 7]);
assert((index[$-$/2] = 2) == [2, 4]);
// opIndexOpAssign
assert((index[8] += 2) == [2, 8]);
assert((index[$] += 2) == [2, 8]);
assert((index[$-1] += 2) == [2, 7]);
assert((index[$-$/2] += 2) == [2, 4]);
// opDollar is only one-dimensional
static assert(!is(typeof(index[$, $])));
static assert(!is(typeof(-index[$, $])));
static assert(!is(typeof(index[$, $] = 2)));
static assert(!is(typeof(index[$, $] += 2)));
// multi dimensional indexing
static struct ArrayExp
{
int[] opIndex(int a, int b)
{
return [a, b];
}
int[] opIndexUnary(string op)(int a, int b)
{
return [a, b];
}
int[] opIndexAssign(int val, int a, int b)
{
return [val, a, b];
}
int[] opIndexOpAssign(string op)(int val, int a, int b)
{
return [val, a, b];
}
int opDollar(int dim)()
{
return dim;
}
}
ArrayExp array;
// opIndex
assert(array[8, 8] == [8, 8]);
assert(array[$, $] == [0, 1]);
assert(array[$, $-1] == [0, 0]);
assert(array[2, $-$/2] == [2, 1]);
// opIndexUnary
assert(-array[8, 8] == [8, 8]);
assert(-array[$, $] == [0, 1]);
assert(-array[$, $-1] == [0, 0]);
assert(-array[2, $-$/2] == [2, 1]);
// opIndexAssign
assert((array[8, 8] = 2) == [2, 8, 8]);
assert((array[$, $] = 2) == [2, 0, 1]);
assert((array[$, $-1] = 2) == [2, 0, 0]);
assert((array[2, $-$/2] = 2) == [2, 2, 1]);
// opIndexOpAssign
assert((array[8, 8] += 2) == [2, 8, 8]);
assert((array[$, $] += 2) == [2, 0, 1]);
assert((array[$, $-1] += 2) == [2, 0, 0]);
assert((array[2, $-$/2] += 2) == [2, 2, 1]);
// one dimensional slicing
static struct SliceExp
{
int[] opSlice(int a, int b)
{
return [a, b];
}
int[] opSliceUnary(string op)(int a, int b)
{
return [a, b];
}
int[] opSliceAssign(int val, int a, int b)
{
return [val, a, b];
}
int[] opSliceOpAssign(string op)(int val, int a, int b)
{
return [val, a, b];
}
int opDollar()
{
return 8;
}
}
SliceExp slice;
// opSlice
assert(slice[0 .. 8] == [0, 8]);
assert(slice[0 .. $] == [0, 8]);
assert(slice[0 .. $-1] == [0, 7]);
assert(slice[$-3 .. $-1] == [5, 7]);
// opSliceUnary
assert(-slice[0 .. 8] == [0, 8]);
assert(-slice[0 .. $] == [0, 8]);
assert(-slice[0 .. $-1] == [0, 7]);
assert(-slice[$-3 .. $-1] == [5, 7]);
// opSliceAssign
assert((slice[0 .. 8] = 2) == [2, 0, 8]);
assert((slice[0 .. $] = 2) == [2, 0, 8]);
assert((slice[0 .. $-1] = 2) == [2, 0, 7]);
assert((slice[$-3 .. $-1] = 2) == [2, 5, 7]);
// opSliceOpAssign
assert((slice[0 .. 8] += 2) == [2, 0, 8]);
assert((slice[0 .. $] += 2) == [2, 0, 8]);
assert((slice[0 .. $-1] += 2) == [2, 0, 7]);
assert((slice[$-3 .. $-1] += 2) == [2, 5, 7]);
// test different kinds of opDollar
auto dollar(string opDollar)()
{
static struct Dollar
{
size_t opIndex(size_t a) { return a; }
mixin(opDollar);
}
Dollar d;
return d[$];
}
assert(dollar!q{@property size_t opDollar() { return 8; }}() == 8);
assert(dollar!q{template opDollar(size_t dim) { enum opDollar = dim; }}() == 0);
assert(dollar!q{static const size_t opDollar = 8;}() == 8);
assert(dollar!q{enum opDollar = 8;}() == 8);
assert(dollar!q{size_t length() { return 8; } alias length opDollar;}() == 8);
}
/**************************************/
void test19()
{
static struct Foo
{
int[] opSlice(int a, int b)
{
return [a, b];
}
int opDollar(int dim)()
{
return dim;
}
}
Foo foo;
assert(foo[0 .. $] == [0, 0]);
}
/**************************************/
// 9453
struct Foo9453
{
static int ctor = 0;
this(string bar) { ++ctor; }
void opIndex(size_t i) const {}
void opSlice(size_t s, size_t e) const {}
size_t opDollar(int dim)() const if (dim == 0) { return 1; }
}
void test9453()
{
assert(Foo9453.ctor == 0); Foo9453("bar")[$-1];
assert(Foo9453.ctor == 1); Foo9453("bar")[0..$];
assert(Foo9453.ctor == 2);
}
/**************************************/
// 9496
struct S9496
{
static S9496* ptr;
size_t opDollar()
{
assert(ptr is &this);
return 10;
}
void opSlice(size_t , size_t)
{
assert(ptr is &this);
}
void getSlice()
{
assert(ptr is &this);
this[1 .. opDollar()];
this[1 .. $];
}
}
void test9496()
{
S9496 s;
S9496.ptr = &s;
s.getSlice();
s[1 .. $];
}
/**************************************/
// 9689
struct B9689(T)
{
T val;
@disable this(this);
bool opEquals(this X, B)(auto ref B b)
{
//pragma(msg, "+", X, ", B = ", B, ", ref = ", __traits(isRef, b));
return this.val == b.val;
//pragma(msg, "-", X, ", B = ", B, ", ref = ", __traits(isRef, b));
}
}
struct S9689
{
B9689!int num;
}
void test9689()
{
B9689!S9689 b;
}
/**************************************/
// 9694
struct S9694
{
bool opEquals(ref S9694 rhs)
{
assert(0);
}
}
struct T9694
{
S9694 s;
}
void test9694()
{
T9694 t;
assert(thrown!Error(typeid(T9694).equals(&t, &t)));
}
/**************************************/
// 10064
void test10064()
{
static struct S
{
int x = 3;
@disable this();
this(int)
{ x = 7; }
int opSlice(size_t, size_t)
{ return 0; }
@property size_t opDollar()
{
assert(x == 7 || x == 3); // fails
assert(x == 7);
return 0;
}
}
auto x = S(0)[0 .. $];
}
/**************************************/
// 12585
void test12585()
{
struct Bar
{
int opIndex(size_t index)
{
return 0;
}
}
struct Foo
{
Bar opIndex(size_t index)
{
throw new Exception("Fail");
}
}
Foo foo()
{
return Foo();
}
void catchStuff(E)(lazy E expression)
{
try
expression();
catch (Exception e) {}
}
catchStuff(foo()[0][0]); // OK <- NG
catchStuff(foo().opIndex(0)[0]); // OK
catchStuff(foo()[0].opIndex(0)); // OK
Foo f; catchStuff(f[0][0]); // OK
}
/**************************************/
// 10394
void test10394()
{
alias Seq!(int, int) Pair;
Pair pair;
struct S1
{
int opBinary(string op)(Pair) { return 1; }
bool opEquals(Pair) { return true; }
int opOpAssign(string op)(Pair) { return 1; }
}
S1 s1;
assert((s1 + pair) == 1);
assert((s1 == pair) == true);
assert((s1 *= pair) == 1);
struct S2
{
int opBinaryRight(string op)(Pair lhs) { return 1; }
int opCmp(Pair) { return -1; }
}
S2 s2;
assert((pair in s2) == 1);
assert(s2 < pair);
}
/**************************************/
// 10597
struct R10597
{
void opIndex(int) {}
void opSlice(int, int) {}
int opDollar();
}
R10597 r;
struct S10597
{
static assert(is(typeof(r[0]))); //ok
static assert(is(typeof(r[$]))); //fails
static assert(is(typeof(r[0..0]))); //ok
static assert(is(typeof(r[$..$]))); //fails
void foo()
{
static assert(is(typeof(r[0]))); //ok
static assert(is(typeof(r[$]))); //ok
static assert(is(typeof(r[0..0]))); //ok
static assert(is(typeof(r[$..$]))); //ok
}
}
static assert(is(typeof(r[0]))); //ok
static assert(is(typeof(r[$]))); //fails
static assert(is(typeof(r[0..0]))); //ok
static assert(is(typeof(r[$..$]))); //fails
void test10597()
{
static assert(is(typeof(r[0]))); //ok
static assert(is(typeof(r[$]))); //ok
static assert(is(typeof(r[0..0]))); //ok
static assert(is(typeof(r[$..$]))); //ok
}
/**************************************/
// 10567
// doesn't require thunk
struct S10567x1n { int value; int opCmp(ref const S10567x1n rhs) const { return 0; } }
// requires thunk
struct S10567y1n { int value; int opCmp(const S10567y1n rhs) const { return 0; } }
struct S10567y1t { int value; int opCmp(S)(const S rhs) const { return 0; } }
// doesn't support const comparison
struct S10567z1n { int value; int opCmp(const S10567z1n rhs) { return 0; } }
struct S10567z1t { int value; int opCmp(S)(const S rhs) { return 0; } }
/+
struct S10567x2n { S10567x1n s; this(int n) { s = typeof(s)(n); } alias s this; }
struct S10567y2n { S10567y1n s; this(int n) { s = typeof(s)(n); } alias s this; }
struct S10567y2t { S10567y1t s; this(int n) { s = typeof(s)(n); } alias s this; }
struct S10567z2n { S10567z1n s; this(int n) { s = typeof(s)(n); } alias s this; }
struct S10567z2t { S10567z1t s; this(int n) { s = typeof(s)(n); } alias s this; }
struct S10567d1
{
int value;
int opDispatch(string name, S)(const S rhs) const if (name == "opCmp")
{ assert(0); }
}
struct S10567d2
{
int value;
template opDispatch(string name) if (name == "opCmp")
{
int opDispatch(const S rhs) const
{ assert(0); }
}
}
// recursive alias this + opCmp searching
struct S10567r1
{
static S10567r2 t;
ref S10567r2 payload() { return t; }
alias payload this;
int opCmp(const S10567r1 s) const { return 0; }
}
struct S10567r2
{
static S10567r1 s;
ref S10567r1 payload() { return s; }
alias payload this;
}
+/
void test10567()
{
foreach (S; Seq!(S10567x1n/+, S10567x2n+/))
{
S sx = S(1);
S sy = S(2);
assert(!(sx < sy) && !(sx > sy));
assert(sx.opCmp(sy) == 0);
assert(typeid(S).compare(&sx, &sy) == 0);
static if (is(S == S10567x1n))
assert(cast(void*)typeid(S).xopCmp == cast(void*)&S.opCmp, S.stringof);
}
foreach (S; Seq!(S10567y1n, S10567y1t/+, S10567y2n, S10567y2t+/))
{
S sx = S(1);
S sy = S(2);
assert(!(sx < sy) && !(sx > sy));
assert(sx.opCmp(sy) == 0);
assert(typeid(S).compare(&sx, &sy) == 0);
}
foreach (S; Seq!(S10567z1n, S10567z1t/+, S10567z2n, S10567z2t+/))
{
S sx = S(1);
S sy = S(2);
assert(!(sx < sy) && !(sx > sy));
assert(sx.opCmp(sy) == 0);
try
{
auto x = typeid(S).compare(&sx, &sy);
assert(0);
}
catch (Error e) { assert(e.msg[$-15 .. $] == "not implemented"); }
}
/+
foreach (S; Seq!(S10567d1, S10567d2))
{
int[S] aa;
aa[S(1)] = 10; aa[S(1)] = 1;
aa[S(2)] = 20; aa[S(2)] = 2;
assert(aa.length == 2);
foreach (k, v; aa)
assert(k.value == v);
S sx = S(1);
S sy = S(2);
// Don't invoke opDispatch!"opCmp"
assert(typeid(S).compare(&sx, &sy) != 0);
}
+/
}
/**************************************/
// 11062
struct S11062ia
{
struct S1
{
void opIndexAssign(int val, int key) {}
}
struct S2
{
S1 headers;
}
private S2 m_obj;
@property S2 get() { return m_obj; }
alias get this;
}
struct S11062sa
{
struct S1
{
void opSliceAssign(int val, int lwr, int upr) {}
}
struct S2
{
S1 headers;
}
private S2 m_obj;
@property S2 get() { return m_obj; }
alias get this;
}
void test11062()
{
auto sia = S11062ia();
sia.headers[1] = 1; // bug
auto ssa = S11062sa();
ssa.headers[1..2] = 1; // bug
}
/**************************************/
// 11311
void test11311()
{
static int ctor, cpctor, dtor;
static struct S
{
this(int) { ++ctor; }
this(this) { ++cpctor; }
~this() { ++dtor; }
}
static struct Arr
{
S data;
ref S opIndex(int) { return data; }
ref S opSlice(int, int) { return data; }
}
{
Arr a = Arr(S(1));
assert(ctor == 1);
assert(cpctor == 0);
assert(dtor == 0);
auto getA1() { return a; }
//getA1().opIndex(1); // OK
getA1()[1]; // NG
assert(ctor == 1);
assert(cpctor == 1); // getA() returns a copy of a
assert(dtor == 1); // temporary returned by getA() should be destroyed
}
assert(dtor == 2);
assert(ctor + cpctor == dtor);
ctor = cpctor = dtor = 0;
{
Arr a = Arr(S(1));
assert(ctor == 1);
assert(cpctor == 0);
assert(dtor == 0);
auto getA2() { return a; }
//getA2().opSlice(1, 2); // OK
getA2()[1..2]; // NG
assert(ctor == 1);
assert(cpctor == 1); // getA() returns a copy of a
assert(dtor == 1); // temporary returned by getA() should be destroyed
}
assert(dtor == 2);
assert(ctor + cpctor == dtor);
}
/**************************************/
// 12193
void test12193()
{
struct Foo
{
bool bar;
alias bar this;
void opOpAssign(string op)(size_t x)
{
bar = false;
}
}
Foo foo;
foo <<= 1;
}
/**************************************/
// 14057
struct W14057
{
int[] subType;
alias subType this;
W14057 opSlice(size_t, size_t)
{
return this;
}
}
void test14057()
{
auto w = W14057();
W14057 w2 = w[0 .. 1337];
}
/**************************************/
int main()
{
test1();
test2();
test3();
test4();
test5();
test6();
test7();
test8();
test9();
test10();
test11();
test4099();
test12();
test13();
test14();
test15();
test16();
test17();
test3789();
test10037();
test6798();
test12904();
test7641();
test8434();
test18();
test19();
test9453();
test9496();
test9689();
test9694();
test10064();
test12585();
test10394();
test10567();
test11062();
test11311();
test14057();
printf("Success\n");
return 0;
}
|
D
|
/**
Copyright 2018 Mark Fisher
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
**/
module dxx.tools.cfg;
private import dxx.tools;
private import eph.args;
// Manage config vars
class ConfigTool : ToolBase {
override int runTool(WorkflowJob job) {
return Tool.OK;
}
};
|
D
|
module test;
import core.vararg;
import std.stdio;
import std.string;
extern(C) int printf(const char*, ...);
/*******************************************/
struct S1
{
void* function(void*) fn;
}
template M1()
{
S1 s;
}
void test1()
{
S1 s2;
mixin M1;
assert(s.fn == null);
}
/*******************************************/
enum Qwert { yuiop }
int asdfg(Qwert hjkl) { return 1; }
int asdfg(uint zxcvb) { return 2; }
void test2()
{
int nm = 2;
assert(asdfg(nm) == 2);
assert(asdfg(cast(int) nm) == 2);
assert(asdfg(3) == 2);
assert(asdfg(cast(int) 3) == 2);
assert(asdfg(3L) == 2);
assert(asdfg(cast(int) 3L) == 2);
assert(asdfg(3 + 2) == 2);
assert(asdfg(cast(int) (3 + 2)) == 2);
assert(asdfg(nm + 2) == 2);
assert(asdfg(cast(int) (nm + 2)) == 2);
assert(asdfg(3 + nm) == 2);
assert(asdfg(cast(int) (3 + nm)) == 2);
}
/*******************************************/
template Qwert3(string yuiop) {
immutable string Qwert3 = cast(string)yuiop;
}
template Asdfg3(string yuiop) {
immutable string Asdfg3 = cast(string)Qwert3!(cast(string)(cast(string)yuiop ~ cast(string)"hjkl"));
}
void test3()
{
string zxcvb = Asdfg3!(null);
assert(zxcvb == "hjkl");
assert(zxcvb == "hjkl" ~ null);
}
/*******************************************/
template Qwert4(string yuiop)
{
immutable string Qwert4 = cast(string)(yuiop ~ "asdfg" ~ yuiop);
}
void test4()
{
string hjkl = Qwert4!(null);
assert(hjkl == "asdfg");
}
/*******************************************/
void test6()
{
struct Foo
{
void foo() { }
}
alias Foo Bar;
Bar a;
a.foo();
}
/*******************************************/
void test7()
{
struct Foo
{
alias typeof(this) ThisType;
alias typeof(this) ThatType;
}
assert(is(Foo.ThisType == Foo));
assert(is(Foo.ThatType == Foo));
}
/*******************************************/
void test8()
{
int[] test;
test.length = 10;
// Show address of array start and its length (10)
writefln("%s %s", cast(uint)test.ptr, test.length);
test.length = 1;
// Show address of array start and its length (1)
writefln("%s %s", cast(uint)test.ptr, test.length);
test.length = 8;
// Show address of array start and its length (8)
writefln("%s %s", cast(uint)test.ptr, test.length);
test.length = 0;
// Shows 0 and 0!
writefln("%s %s", cast(uint)test.ptr, test.length);
assert(test.length == 0);
assert(test.ptr != null);
}
/*******************************************/
cdouble y9;
cdouble f9(cdouble x)
{
return (y9 = x);
}
void test9()
{
f9(1.0+2.0i);
assert(y9 == 1.0+2.0i);
}
/*******************************************/
class CBase10
{
this() { }
}
void foo10( CBase10 l )
{
}
void test10()
{
if (1)
{
foo10( new class() CBase10
{
this() { super(); }
}
);
}
return;
}
/*******************************************/
struct Foo11
{
static
int func(T)(T a) { assert(a == 1); return 0; }
}
void test11()
{
auto a = Foo11.init.func(1);
a = Foo11.init.func!(int)(1);
a = Foo11.func(1);
a = Foo11.func!(int)(1);
}
/*******************************************/
void test12()
{
class ExceptioN { }
class ExceptioX { }
static assert(ExceptioN.mangleof[0 ..$-1] == ExceptioX.mangleof[0 .. $-1]);
}
/*******************************************/
template check( char ch1, char ch2)
{
const bool check = ch1 == ch2;
}
void test13()
{
const char[] s = "123+456" ;
assert(check!( '+', s[3] ) == true);
}
/*******************************************/
void test14()
{
static const char[] test=['a','b','c','d'];
static assert(test==['a','b','c','d']);
static assert(['a','b','c','d']== test);
}
/*******************************************/
void func15(...)
in {
writefln("Arguments len = %d\n", _arguments.length);
assert(_arguments.length == 2);
}
body {
}
void test15()
{
func15(1, 2);
}
/*******************************************/
void test17()
{
void delegate() y = { };
y();
}
/*******************************************/
abstract class Pen { int foo(); }
class Penfold : Pen {
override int foo() { return 1; }
}
class Pinky : Pen {
override int foo() { return 2; }
}
class Printer {
void vprint(Pen obj) {
assert(obj.foo() == 1 || obj.foo() == 2);
}
C print(C)(C obj) {
assert(obj.foo() == 1 || obj.foo() == 2);
return obj;
}
}
void test18()
{
Printer p = new Printer;
p.print(new Pinky);
p.print(new Penfold);
with (p)
{
vprint(new Pinky);
vprint(new Penfold);
print!(Pinky)(new Pinky);
print!(Penfold)(new Penfold);
p.print(new Pinky);
p.print(new Penfold);
print(new Pinky);
print(new Penfold);
}
}
/*******************************************/
class A19
{
void s() {}
}
class B19 : A19
{
alias A19.s s;
static void s(int i) {}
override void s() {}
}
class C19
{
void f() {
B19.s(0);
}
}
void test19()
{
}
/*******************************************/
class U {}
class T : U {}
void test20()
{
T* ptr;
T[2] sar;
T[] dar;
// all of the following should work according to the "Implicit
// Conversions" section of the spec
tPtr(ptr);
tPtr(sar.ptr);
tPtr(dar.ptr);
tDar(sar);
// uPtr(ptr); // T* => U*
// uPtr(sar); // T[2] => U*
// uPtr(dar); // T[] => U*
// uSar(sar); // T[2] => U[2]
// uDar(sar); // T[2] => U[]
uDar(dar); // T[] => const(U)[]
vPtr(ptr); // T* => void*
vPtr(sar.ptr);
vPtr(dar.ptr);
vDar(sar);
vDar(dar); // works, but T[] => void[] isn't mentioned in the spec
}
void tPtr(T*t){}
void tDar(T[]t){}
void uPtr(U*u){}
void uSar(U[2]u){}
void uDar(const(U)[]u){}
void vPtr(void*v){}
void vDar(void[]v){}
/*******************************************/
struct Foo21
{
int i;
}
template some_struct_instance(T)
{
static Foo21 some_struct_instance =
{
5,
};
}
void test21()
{
alias some_struct_instance!(int) inst;
assert(inst.i == 5);
}
/*******************************************/
struct Foo22(T) {}
void test22()
{
int i;
if ((Foo22!(char)).init == (Foo22!(char)).init)
i = 1;
assert(i == 1);
}
/*******************************************/
void test23()
{
auto t=['a','b','c','d'];
writeln(typeid(typeof(t)));
assert(is(typeof(t) == char[]));
const t2=['a','b','c','d','e'];
writeln(typeid(typeof(t2)));
assert(is(typeof(t2) == const(const(char)[])));
}
/*******************************************/
int foo24(int i ...)
{
return i;
}
void test24()
{
assert(foo24(3) == 3);
}
/*******************************************/
void test25()
{
ireal x = 4.0Li;
ireal y = 4.0Li;
ireal z = 4Li;
creal c = 4L + 0Li;
}
/*******************************************/
struct Foo26
{
int a;
static Foo26 opCall(int i)
{ Foo26 f;
f.a += i;
return f;
}
}
void test26()
{ Foo26 f;
f = cast(Foo26)3;
assert(f.a == 3);
Foo26 g = 3;
assert(g.a == 3);
}
/*******************************************/
struct S27
{
int x;
void opAssign(int i)
{
x = i + 1;
}
}
void test27()
{
S27 s;
s = 1;
assert(s.x == 2);
}
/*******************************************/
class C28
{
int x;
void opAssign(int i)
{
x = i + 1;
}
}
void test28()
{
// No longer supported for 2.0
// C28 s = new C28;
// s = 1;
// assert(s.x == 2);
}
/*******************************************/
struct S29
{
static S29 opCall(int v)
{
S29 result;
result.v = v;
return result;
}
int a;
int v;
int x,y,z;
}
int foo29()
{
auto s = S29(5);
return s.v;
}
void test29()
{
int i = foo29();
printf("%d\n", i);
assert(i == 5);
}
/*******************************************/
struct S30
{
static S30 opCall(int v)
{
S30 result;
void bar()
{
result.v += 1;
}
result.v = v;
bar();
return result;
}
int a;
int v;
int x,y,z;
}
int foo30()
{
auto s = S30(5);
return s.v;
}
void test30()
{
int i = foo30();
printf("%d\n", i);
assert(i == 6);
}
/*******************************************/
struct S31
{
static void abc(S31 *r)
{
r.v += 1;
}
static S31 opCall(int v)
{
S31 result;
void bar()
{
abc(&result);
}
result.v = v;
bar();
return result;
}
int a;
int v;
int x,y,z;
}
int foo31()
{
auto s = S31(5);
return s.v;
}
void test31()
{
int i = foo31();
printf("%d\n", i);
assert(i == 6);
}
/*******************************************/
struct T32
{
int opApply(int delegate(ref int i) dg)
{
int i;
return dg(i);
}
}
struct S32
{
static void abc(S32 *r)
{
r.v += 1;
}
static S32 opCall(int v)
{
S32 result;
T32 t;
result.v = v;
foreach (i; t)
{
result.v += 1;
break;
}
return result;
}
int a;
int v;
int x,y,z;
}
int foo32()
{
auto s = S32(5);
return s.v;
}
void test32()
{
int i = foo32();
printf("%d\n", i);
assert(i == 6);
}
/*******************************************/
class Confectionary
{
this(int sugar)
{
//if (sugar < 500)
// tastiness = 200;
//for (int i = 0; i < 10; ++i)
// tastiness = 300;
//int[] tastinesses_array;
//foreach (n; tastinesses_array)
// tastiness = n;
//int[int] tastinesses_aa;
//foreach (n; tastinesses_aa)
// tastiness = n;
tastiness = 1;
}
const int tastiness;
}
void test33()
{
}
/*******************************************/
template a34(string name, T...)
{
string a34(string name,T t)
{
string localchar;
foreach (a34; T)
{
writefln(`hello`);
localchar ~= a34.mangleof;
}
return localchar;
}
}
void test34()
{
writeln(a34!("Adf"[], typeof("adf"),uint)("Adf"[],"adf",1234));
}
/*******************************************/
template a35(string name, T...)
{
int a35(M...)(M m)
{
return 3;
}
}
void test35()
{
assert(a35!("adf")() == 3);
}
/*******************************************/
template a36(AnotherT,string name,T...){
AnotherT a36(M...)(M){
AnotherT localchar;
foreach(a;T)
{
writefln(`hello`);
localchar~=a.mangleof;
}
return cast(AnotherT)localchar;
}
}
void test36()
{
string b="adf";
uint i=123;
char[3] c="Adf";
writeln(a36!(typeof(b),"Adf")());
}
/*******************************************/
struct Q37 {
Y37 opCast() {
return Y37.init;
}
}
struct Y37 {
Q37 asdfg() {
return Q37.init;
}
void hjkl() {
Q37 zxcvb = asdfg(); // line 13
}
}
void test37()
{
}
/*******************************************/
class C38 { }
const(Object)[] foo38(C38[3] c) @system
{ const(Object)[] x = c;
return x;
}
void test38()
{
}
/*******************************************/
void test39()
{
void print(string[] strs)
{
writeln(strs);
assert(format("%s", strs) == `["Matt", "Andrew"]`);
}
print(["Matt", "Andrew"]);
}
/*******************************************/
void test40()
{
class C
{
Object propName()
{
return this;
}
}
auto c = new C;
with (c.propName)
{
writeln(toString());
}
auto foo = c.propName;
}
/*******************************************/
void test41()
{
auto test = new char [2];
int x1, x2, x3;
char[] foo1() { x1++; return test; }
int foo2() { x2++; return 0; }
int foo3() { x3++; return 1; }
test [] = 'a';
test = test [0 .. 1];
foo1() [foo2() .. foo3()] = 'b';
assert(x1 == 1);
assert(x2 == 1);
assert(x3 == 1);
//test [0 .. 2] = 'b'; // this line should assert
writef ("%s\n", test.ptr [0 .. 2]);
}
/*******************************************/
void test42()
{
struct X { int x; }
X x;
assert(x.x == 0);
x = x.init;
assert(x.x == 0);
}
/*******************************************/
struct A43
{
static const MY_CONST_STRING = "hello";
void foo()
{
// This will either print garbage or throw a UTF exception.
// But if never_called() is commented out, then it will work.
writefln("%s", MY_CONST_STRING);
}
}
void never_called43()
{
// This can be anything; there just needs to be a reference to
// A43.MY_CONST_STRING somewhere.
writefln("%s", A43.MY_CONST_STRING);
}
void test43()
{
A43 a;
a.foo();
}
/*******************************************/
class A44
{
static const MY_CONST_STRING = "hello";
this()
{
// This will either print garbage or throw a UTF exception.
// But if never_called() is commented out, then it will work.
writefln("%s", MY_CONST_STRING);
}
}
void never_called44()
{
// This can be anything; there just needs to be a reference to
// A44.MY_CONST_STRING somewhere.
writefln("%s", A44.MY_CONST_STRING);
}
void test44()
{
A44 a = new A44();
}
/*******************************************/
class C45
{
void func(lazy size_t x)
{
(new C45).func(super.toHash());
}
}
void test45()
{
}
/*******************************************/
template T46(double v)
{
double T46 = v;
}
void test46()
{
double g = T46!(double.nan) + T46!(-double.nan);
}
/*******************************************/
void test47()
{
uint* where = (new uint[](5)).ptr;
where[0 .. 5] = 1;
assert(where[2] == 1);
where[0 .. 0] = 0;
assert(where[0] == 1);
assert(where[2] == 1);
}
/*******************************************/
void test48()
{
Object o = new Object();
printf("%.*s\n", typeof(o).classinfo.name.length, typeof(o).classinfo.name.ptr);
printf("%.*s\n", (typeof(o)).classinfo.name.length, (typeof(o)).classinfo.name.ptr);
printf("%.*s\n", (Object).classinfo.name.length, (Object).classinfo.name.ptr);
}
/*******************************************/
void test49()
{
foo49();
}
void foo49()
{
char[] bar;
assert(true, bar ~ "foo");
}
/*******************************************/
void test50()
{
foo50("foo");
}
void foo50(string bar)
{
assert(true, bar ~ "foo");
}
/*******************************************/
struct Foo51
{
static Foo51 opCall()
{
return Foo51.init;
}
private char[] _a;
private bool _b;
}
void test51()
{
}
/*******************************************/
template A52(T ...) { }
mixin A52!(["abc2", "def"]);
void test52()
{
}
/*******************************************/
enum: int
{
AF_INET53 = 2,
PF_INET53 = AF_INET53,
}
enum: int
{
SOCK_STREAM53 = 1,
}
struct sockaddr_in53
{
int sin_family = AF_INET53;
}
enum AddressFamily53: int
{
INET = AF_INET53,
}
enum SocketType53: int
{
STREAM = SOCK_STREAM53,
}
class Socket53
{
this(AddressFamily53 af, SocketType53 type)
{
}
}
void test53()
{
new Socket53(AddressFamily53.INET, SocketType53.STREAM);
}
/*******************************************/
void test54()
{
int[2][] a;
a ~= [1,2];
assert(a.length == 1);
assert(a[0][0] == 1);
assert(a[0][1] == 2);
}
/*******************************************/
void test55()
{
float[][] a = new float [][](1, 1);
if((a.length != 1) || (a[0].length != 1)){
assert(0);
}
if (a[0][0] == a[0][0]){
assert(0);
}
}
/*******************************************/
void test58()
{
struct S
{
int i;
int[4] bar = 4;
float[4] abc;
}
static S a = {i: 1};
static S b;
writefln("a.bar: %s, %s", a.bar, a.abc);
assert(a.i == 1);
assert(a.bar[0] == 4);
assert(a.bar[1] == 4);
assert(a.bar[2] == 4);
assert(a.bar[3] == 4);
writefln("b.bar: %s, %s", b.bar, b.abc);
assert(b.i == 0);
assert(b.bar[0] == 4);
assert(b.bar[1] == 4);
assert(b.bar[2] == 4);
assert(b.bar[3] == 4);
}
/*******************************************/
void bug59(string s)()
{
writeln(s);
writeln(s.length);
}
void test59()
{
bug59!("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234")();
}
/*******************************************/
class Foo60(T)
{
this() { unknown_identifier; }
}
void test60()
{
bool foobar = is( Foo60!(int) );
assert(!foobar);
}
/*******************************************/
void repeat( int n, void delegate() dg )
{
printf("n = %d\n", n);
if( n&1 ) dg();
if( n/2 ) repeat( n/2, {dg();dg();} );
}
void test61()
{
repeat( 10, {printf("Hello\n");} );
}
/*******************************************/
void test62()
{
Vector62 a;
a.set(1,2,24);
a = a * 2;
writeln(a.x, a.y, a.z);
assert(a.x == 2);
assert(a.y == 4);
assert(a.z == 48);
}
struct Vector62
{
float x,y,z;
// constructor
void set(float _x, float _y, float _z)
{
x = _x;
y = _y;
z = _z;
}
Vector62 opMul(float s)
{
Vector62 ret;
ret.x = x*s;
ret.y = y*s;
ret.z = z*s;
return ret;
}
}
/*******************************************/
struct Data63
{
int x, y;
/// To make size > 8 so NRVO is used.
/// Program runs correctly with this line commented out:
byte filler;
}
Data63 frob(ref Data63 d)
{
Data63 ret;
ret.y = d.x - d.y;
ret.x = d.x + d.y;
return ret;
}
void test63()
{
Data63 d; d.x = 1; d.y = 2;
d = frob(d);
writeln(d.x);
writeln(d.y);
assert(d.x == 3 && d.y == -1);
}
/*******************************************/
class Foo64
{
this() { writefln("Foo64 created"); }
~this() { writefln("Foo64 destroyed"); }
}
template Mix64()
{
void init() {
ptr = new Foo64;
}
Foo64 ptr;
}
class Container64
{
this() { init(); }
mixin Mix64;
}
void test64()
{
auto x = new Container64;
assert(!(x.classinfo.flags & 2));
}
/*******************************************/
struct Vector65(T, uint dim)
{
T[dim] data;
}
T dot65(T, uint dim)(Vector65!(T,dim) a, Vector65!(T,dim) b)
{
T tmp;
for ( int i = 0; i < dim; ++i )
tmp += a.data[i] * b.data[i];
return tmp;
}
void test65()
{
Vector65!(double,3u) a,b;
auto t = dot65(a,b);
}
/*******************************************/
void main()
{
printf("Start\n");
test1();
test2();
test3();
test4();
test6();
test7();
test8();
test9();
test10();
test11();
test12();
test13();
test14();
test15();
test17();
test18();
test19();
test20();
test21();
test22();
test23();
test24();
test25();
test26();
test27();
test28();
test29();
test30();
test31();
test32();
test33();
test34();
test35();
test36();
test37();
test38();
test39();
test40();
test41();
test42();
test43();
test44();
test45();
test46();
test47();
test48();
test49();
test50();
test51();
test52();
test53();
test54();
test55();
test58();
test59();
test60();
test61();
test62();
test63();
test64();
test65();
printf("Success\n");
}
|
D
|
/*
DIrrlicht - D Bindings for Irrlicht Engine
Copyright (C) 2014- Danyal Zia (catofdanyal@yahoo.com)
This software is provided 'as-is', without any express or
implied warranty. In no event will the authors be held
liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute
it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented;
you must not claim that you wrote the original software.
If you use this software in a product, an acknowledgment
in the product documentation would be appreciated but
is not required.
2. Altered source versions must be plainly marked as such,
and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any
source distribution.
*/
module dirrlicht.keymap;
import dirrlicht.keycodes;
/// enumeration for key actions. Used for example in the FPS Camera.
enum KeyAction {
MoveForward = 0,
MoveBackward,
StrafeLeft,
StrafeRight,
Jump,
Crouch,
Count,
}
/// Struct storing which key belongs to which action.
struct KeyMap {
KeyAction action;
KeyCode keyCode;
}
@nogc nothrow extern (C):
struct irr_SKeyMap {
KeyAction action;
KeyCode keyCode;
}
|
D
|
/**
* D header file for POSIX.
*
* Copyright: Copyright Robert Klotzner 2012
* License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
* Authors: Robert Klotzner
* Standards: The Open Group Base Specifications Issue 6 IEEE Std 1003.1, 2004 Edition
*/
module core.sys.posix.sys.statvfs;
private import core.stdc.config;
private import core.sys.posix.config;
public import core.sys.posix.sys.types;
version (Posix):
extern (C) :
version(linux) {
static if(__WORDSIZE == 32)
{
version=_STATVFSBUF_F_UNUSED;
}
struct statvfs_t
{
c_ulong f_bsize;
c_ulong f_frsize;
fsblkcnt_t f_blocks;
fsblkcnt_t f_bfree;
fsblkcnt_t f_bavail;
fsfilcnt_t f_files;
fsfilcnt_t f_ffree;
fsfilcnt_t f_favail;
c_ulong f_fsid;
version(_STATVFSBUF_F_UNUSED)
{
int __f_unused;
}
c_ulong f_flag;
c_ulong f_namemax;
int[6] __f_spare;
}
/* Definitions for the flag in `f_flag'. These definitions should be
kept in sync with the definitions in <sys/mount.h>. */
static if(__USE_GNU)
{
enum FFlag
{
ST_RDONLY = 1, /* Mount read-only. */
ST_NOSUID = 2,
ST_NODEV = 4, /* Disallow access to device special files. */
ST_NOEXEC = 8, /* Disallow program execution. */
ST_SYNCHRONOUS = 16, /* Writes are synced at once. */
ST_MANDLOCK = 64, /* Allow mandatory locks on an FS. */
ST_WRITE = 128, /* Write on file/directory/symlink. */
ST_APPEND = 256, /* Append-only file. */
ST_IMMUTABLE = 512, /* Immutable file. */
ST_NOATIME = 1024, /* Do not update access times. */
ST_NODIRATIME = 2048, /* Do not update directory access times. */
ST_RELATIME = 4096 /* Update atime relative to mtime/ctime. */
}
} /* Use GNU. */
else
{ // Posix defined:
enum FFlag
{
ST_RDONLY = 1, /* Mount read-only. */
ST_NOSUID = 2
}
}
static if( __USE_FILE_OFFSET64 )
{
int statvfs64 (const char * file, statvfs_t* buf);
alias statvfs64 statvfs;
int fstatvfs64 (int fildes, statvfs_t *buf);
alias fstatvfs64 fstatvfs;
}
else
{
int statvfs (const char * file, statvfs_t* buf);
int fstatvfs (int fildes, statvfs_t *buf);
}
}
else
{
struct statvfs_t
{
c_ulong f_bsize;
c_ulong f_frsize;
fsblkcnt_t f_blocks;
fsblkcnt_t f_bfree;
fsblkcnt_t f_bavail;
fsfilcnt_t f_files;
fsfilcnt_t f_ffree;
fsfilcnt_t f_favail;
c_ulong f_fsid;
c_ulong f_flag;
c_ulong f_namemax;
}
enum FFlag
{
ST_RDONLY = 1, /* Mount read-only. */
ST_NOSUID = 2
}
int statvfs (const char * file, statvfs_t* buf);
int fstatvfs (int fildes, statvfs_t *buf);
}
|
D
|
/*
Album Art plugin for DeaDBeeF
Copyright (C) 2009-2011 Viktor Semykin <thesame.ml@gmail.com>
Copyright (C) 2009-2013 Alexey Yakovenko <waker@users.sourceforge.net>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
module deadbeef.artwork;
import deadbeef.deadbeef;
enum DDB_ARTWORK_VERSION = 3;
alias artwork_callback = void function(in char *fname, in char *artist, in char *album, void *user_data);
struct DB_artwork_plugin_t {
DB_misc_t plugin;
// returns filename of cached image, or NULL
char* function(in char *fname, in char *artist, in char *album, int size, artwork_callback callback, void *user_data) get_album_art;
// this has to be called to clear queue on exit, before caller terminates
// `fast=1' means "don't wait, just flush queue"
void function(int fast) reset;
// returns path to default album art
immutable char * function() get_default_cover;
// synchronously get filename
char* function(in char *fname, in char *artist, in char *album, int size) get_album_art_sync;
// creates full path string for cache storage
void function(char *path, int size, in char *album, in char *artist, int img_size) make_cache_path;
// creates full path string for cache storage
int function(char *path, int size, in char *fname, in char *album, in char *artist, int img_size) make_cache_path2;
}
|
D
|
/*
TEST_OUTPUT:
---
fail_compilation/diag16977.d(22): Error: undefined identifier `undefined`, did you mean function `undefinedId`?
fail_compilation/diag16977.d(23): Error: cannot implicitly convert expression `"\x01string"` of type `string` to `int`
fail_compilation/diag16977.d(24): Error: template diag16977.templ cannot deduce function from argument types !()(int), candidates are:
fail_compilation/diag16977.d(17): diag16977.templ(S)(S s) if (false)
fail_compilation/diag16977.d(25): Error: cannot implicitly convert expression `5` of type `int` to `string`
fail_compilation/diag16977.d(27): Error: template instance diag16977.test.funcTemplate!string error instantiating
---
*/
// when copying the expression of a default argument, location information is
// replaced by the location of the caller to improve debug information
// verify error messages are displayed for the original location only
string templ(S)(S s) if(false) { return null; }
void test()
{
// local functions to defer evaluation into semantic3 pass
void undefinedId(int x, int y = undefined) {}
void badOp(int x, int y = 1 ~ "string") {}
void lazyTemplate(int x, lazy int y = 4.templ) {}
void funcTemplate(T)(T y = 5) {}
funcTemplate!string();
undefinedId(1);
badOp(2);
lazyTemplate(3);
}
|
D
|
////HEPHERNAAN - WILL SoA
CHAIN IF ~InParty("L0Will")
See("L0Will")
!StateCheck("L0Will",CD_STATE_NOTVALID)
!StateCheck("L#HPH",CD_STATE_NOTVALID)
CombatCounter(0)
Global("L#2WillL#HPH","GLOBAL",0)~ THEN L#HPHB L#HPHWill01
@0
DO ~SetGlobal("L#2WillL#HPH","GLOBAL",1)~
== L0WillB @1
== L#HPHB @2
== L#HPHB @3
== L0WillB @4
== L#HPHB @5
EXIT
CHAIN IF ~InParty("L0Will")
See("L0Will")
!StateCheck("L0Will",CD_STATE_NOTVALID)
!StateCheck("L#HPH",CD_STATE_NOTVALID)
CombatCounter(0)
Global("L#2WillL#HPH","GLOBAL",1)~ THEN L#HPHB L#HPHWill02
@6
DO ~SetGlobal("L#2WillL#HPH","GLOBAL",2)~
== L0WillB @7
== L#HPHB @8
== L#HPHB @9
EXIT
|
D
|
module rabbitmq.examples.amqp_consumer;
import std.stdio;
import std.string;
import std.conv:to;
import symmetry.api.rabbitmq;
enum SUMMARY_EVERY_US = 1000000;
void run(amqp_connection_state_t conn)
{
ulong start_time = now_microseconds();
int received = 0;
int previous_received = 0;
ulong previous_report_time = start_time;
ulong next_summary_time = start_time + SUMMARY_EVERY_US;
amqp_frame_t frame;
ulong now;
while(true)
{
amqp_rpc_reply_t ret;
amqp_envelope_t envelope;
now = now_microseconds();
if (now > next_summary_time) {
int countOverInterval = received - previous_received;
double intervalRate = countOverInterval / ((now - previous_report_time) / 1000000.0);
printf("%d ms: Received %d - %d since last report (%d Hz)\n",
cast(int)(now - start_time) / 1000, received, countOverInterval, cast(int) intervalRate);
previous_received = received;
previous_report_time = now;
next_summary_time += SUMMARY_EVERY_US;
}
amqp_maybe_release_buffers(conn);
ret = amqp_consume_message(conn, &envelope, null, 0);
if (AMQP_RESPONSE_NORMAL != ret.reply_type) {
if (AMQP_RESPONSE_LIBRARY_EXCEPTION == ret.reply_type &&
AMQP_STATUS_UNEXPECTED_STATE == ret.library_error) {
if (AMQP_STATUS_OK != amqp_simple_wait_frame(conn, &frame)) {
return;
}
if (AMQP_FRAME_METHOD == frame.frame_type) {
switch (frame.payload.method.id) {
case AMQP_BASIC_ACK_METHOD:
/* if we've turned publisher confirms on, and we've published a message
* here is a message being confirmed
*/
break;
case AMQP_BASIC_RETURN_METHOD:
/* if a published message couldn't be routed and the mandatory flag was set
* this is what would be returned. The message then needs to be read.
*/
{
amqp_message_t message;
ret = amqp_read_message(conn, frame.channel, &message, 0);
if (AMQP_RESPONSE_NORMAL != ret.reply_type) {
return;
}
amqp_destroy_message(&message);
}
break;
case AMQP_CHANNEL_CLOSE_METHOD:
/* a channel.close method happens when a channel exception occurs, this
* can happen by publishing to an exchange that doesn't exist for example
*
* In this case you would need to open another channel redeclare any queues
* that were declared auto-delete, and restart any consumers that were attached
* to the previous channel
*/
return;
case AMQP_CONNECTION_CLOSE_METHOD:
/* a connection.close method happens when a connection exception occurs,
* this can happen by trying to use a channel that isn't open for example.
*
* In this case the whole connection must be restarted.
*/
return;
default:
stderr.writefln("An unexpected method was received: %s", frame.payload.method.id);
return;
}
}
}
} else {
amqp_destroy_envelope(&envelope);
}
received++;
}
}
int main(string[] args)
{
int status;
string exchange, bindingKey;
amqp_socket_t *socket = null;
amqp_connection_state_t conn;
amqp_bytes_t queuename;
if (args.length< 3) {
stderr.writeln("Usage: amqp_consumer host port\n");
return 1;
}
auto hostname = args[1];
auto port = args[2].to!ushort;
exchange = "amq.direct"; /* argv[3]; */
bindingKey = "test queue"; /* argv[4]; */
conn = amqp_new_connection();
socket = amqp_tcp_socket_new(conn);
if (!socket) {
die("creating TCP socket");
}
status = amqp_socket_open(socket, hostname.toStringz, port);
if (status) {
die("opening TCP socket");
}
die_on_amqp_error(amqp_login(conn, "/".toStringz, 0, 131072, 0, SaslMethod.plain, "guest".toStringz, "guest".toStringz),
"Logging in".toStringz);
amqp_channel_open(conn, 1);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel");
{
amqp_queue_declare_ok_t *r = amqp_queue_declare(conn, 1.to!ushort, cast(amqp_bytes_t)amqp_empty_bytes, 0, 0, 0, 1,
cast(amqp_table_t) amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Declaring queue");
queuename = amqp_bytes_malloc_dup(r.queue);
if (queuename.bytes is null) {
stderr.writeln("Out of memory while copying queue name");
return 1;
}
}
amqp_queue_bind(conn, 1.to!ushort, queuename, amqp_cstring_bytes(exchange.toStringz), amqp_cstring_bytes(bindingKey.toStringz),
cast(amqp_table_t) amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Binding queue");
amqp_basic_consume(conn, 1.to!ushort, queuename,cast(amqp_bytes_t) amqp_empty_bytes, 0, 1, 0, cast(amqp_table_t)amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Consuming");
run(conn);
die_on_amqp_error(amqp_channel_close(conn, 1.to!ushort, AMQP_REPLY_SUCCESS), "Closing channel");
die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection");
die_on_error(amqp_destroy_connection(conn), "Ending connection");
return 0;
}
|
D
|
var int EVT_CRYPT_01_OneTime;
func void evt_crypt_01()
{
if(EVT_CRYPT_01_OneTime == FALSE)
{
Wld_InsertNpc(Lesser_Skeleton,"EVT_CRYPT_ROOM_01_SPAWN_02");
Wld_InsertNpc(Skeleton,"EVT_CRYPT_ROOM_01_SPAWN_04");
Wld_InsertNpc(skeleton_warrior,"EVT_CRYPT_ROOM_01_SPAWN_06");
EVT_CRYPT_01_OneTime = TRUE;
};
};
var int EVT_CRYPT_02_OneTime;
func void evt_crypt_02()
{
if(EVT_CRYPT_02_OneTime == FALSE)
{
Wld_InsertNpc(Lesser_Skeleton,"EVT_CRYPT_ROOM_02_SPAWN_02");
Wld_InsertNpc(Skeleton,"EVT_CRYPT_ROOM_02_SPAWN_04");
Wld_InsertNpc(skeleton_warrior,"EVT_CRYPT_ROOM_02_SPAWN_06");
EVT_CRYPT_02_OneTime = TRUE;
};
};
var int EVT_CRYPT_03_OneTime;
func void evt_crypt_03()
{
if(EVT_CRYPT_03_OneTime == FALSE)
{
Wld_InsertNpc(Lesser_Skeleton,"EVT_CRYPT_ROOM_03_SPAWN_02");
Wld_InsertNpc(Skeleton,"EVT_CRYPT_ROOM_03_SPAWN_04");
Wld_InsertNpc(skeleton_warrior,"EVT_CRYPT_ROOM_03_SPAWN_06");
EVT_CRYPT_03_OneTime = TRUE;
};
};
var int EVT_CRYPT_FINAL_OneTime;
func void evt_crypt_final()
{
if(EVT_CRYPT_FINAL_OneTime == FALSE)
{
EVT_CRYPT_FINAL_OneTime = TRUE;
};
};
func void evt_crypt_room_01_triggerentrance()
{
Crypt_Skeleton_Room_01.aivar[AIV_EnemyOverride] = FALSE;
};
func void evt_crypt_room_02_triggerentrance()
{
Crypt_Skeleton_Room_02.aivar[AIV_EnemyOverride] = FALSE;
};
func void evt_crypt_room_03_triggerentrance()
{
Crypt_Skeleton_Room_03.aivar[AIV_EnemyOverride] = FALSE;
};
|
D
|
/home/louis/pepper/INTECH/4A/RUST/exercices/TP1/ex16_une_lettre_sur_deux/target/rls/debug/deps/ex16_une_lettre_sur_deux-7cf281a75865b7ba.rmeta: src/main.rs
/home/louis/pepper/INTECH/4A/RUST/exercices/TP1/ex16_une_lettre_sur_deux/target/rls/debug/deps/ex16_une_lettre_sur_deux-7cf281a75865b7ba.d: src/main.rs
src/main.rs:
|
D
|
/Users/Leex/TableView_Test/Build/Intermediates.noindex/TableView_Test.build/Debug-iphonesimulator/TableView_Test.build/Objects-normal/x86_64/ViewModel.o : /Users/Leex/TableView_Test/TableView_Test/Supporter/LoadingViewable.swift /Users/Leex/TableView_Test/TableView_Test/AppDelegate.swift /Users/Leex/TableView_Test/TableView_Test/ViewModel/SectionModel.swift /Users/Leex/TableView_Test/TableView_Test/ViewModel/ViewModel.swift /Users/Leex/TableView_Test/TableView_Test/ViewController.swift /Users/Leex/TableView_Test/TableView_Test/Supporter/Extensions.swift /Users/Leex/TableView_Test/TableView_Test/Supporter/ReadPropertyList.swift /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Modules/RxCocoa.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Modules/Differentiator.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Modules/RxDataSources.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Modules/RxSwift.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Modules/RxRelay.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RX.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoa-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Headers/Differentiator-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Headers/RxDataSources-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Headers/RxSwift-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Headers/RxRelay-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoa.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RXObjCRuntime.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoaRuntime.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RXKVOObserver.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoa-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Headers/Differentiator-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Headers/RxDataSources-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Headers/RxSwift-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Headers/RxRelay-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RXDelegateProxy.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/Leex/TableView_Test/Build/Intermediates.noindex/TableView_Test.build/Debug-iphonesimulator/TableView_Test.build/Objects-normal/x86_64/ViewModel~partial.swiftmodule : /Users/Leex/TableView_Test/TableView_Test/Supporter/LoadingViewable.swift /Users/Leex/TableView_Test/TableView_Test/AppDelegate.swift /Users/Leex/TableView_Test/TableView_Test/ViewModel/SectionModel.swift /Users/Leex/TableView_Test/TableView_Test/ViewModel/ViewModel.swift /Users/Leex/TableView_Test/TableView_Test/ViewController.swift /Users/Leex/TableView_Test/TableView_Test/Supporter/Extensions.swift /Users/Leex/TableView_Test/TableView_Test/Supporter/ReadPropertyList.swift /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Modules/RxCocoa.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Modules/Differentiator.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Modules/RxDataSources.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Modules/RxSwift.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Modules/RxRelay.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RX.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoa-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Headers/Differentiator-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Headers/RxDataSources-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Headers/RxSwift-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Headers/RxRelay-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoa.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RXObjCRuntime.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoaRuntime.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RXKVOObserver.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoa-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Headers/Differentiator-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Headers/RxDataSources-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Headers/RxSwift-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Headers/RxRelay-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RXDelegateProxy.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/Leex/TableView_Test/Build/Intermediates.noindex/TableView_Test.build/Debug-iphonesimulator/TableView_Test.build/Objects-normal/x86_64/ViewModel~partial.swiftdoc : /Users/Leex/TableView_Test/TableView_Test/Supporter/LoadingViewable.swift /Users/Leex/TableView_Test/TableView_Test/AppDelegate.swift /Users/Leex/TableView_Test/TableView_Test/ViewModel/SectionModel.swift /Users/Leex/TableView_Test/TableView_Test/ViewModel/ViewModel.swift /Users/Leex/TableView_Test/TableView_Test/ViewController.swift /Users/Leex/TableView_Test/TableView_Test/Supporter/Extensions.swift /Users/Leex/TableView_Test/TableView_Test/Supporter/ReadPropertyList.swift /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Modules/RxCocoa.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Modules/Differentiator.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Modules/RxDataSources.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Modules/RxSwift.swiftmodule/x86_64.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Modules/RxRelay.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RX.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoa-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Headers/Differentiator-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Headers/RxDataSources-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Headers/RxSwift-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Headers/RxRelay-umbrella.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoa.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RXObjCRuntime.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoaRuntime.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RXKVOObserver.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/RxCocoa-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Headers/Differentiator-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Headers/RxDataSources-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Headers/RxSwift-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Headers/RxRelay-Swift.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Headers/_RXDelegateProxy.h /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxCocoa/RxCocoa.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/Differentiator/Differentiator.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxDataSources/RxDataSources.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxSwift/RxSwift.framework/Modules/module.modulemap /Users/Leex/TableView_Test/Build/Products/Debug-iphonesimulator/RxRelay/RxRelay.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.4.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
|
D
|
/home/iot_dev/Documents/Rust_prac/rust_web/simple_iot_api/target/release/deps/bitflags-3481844fb16a27e3.rmeta: /home/iot_dev/.cargo/registry/src/github.com-1ecc6299db9ec823/bitflags-1.2.1/src/lib.rs
/home/iot_dev/Documents/Rust_prac/rust_web/simple_iot_api/target/release/deps/libbitflags-3481844fb16a27e3.rlib: /home/iot_dev/.cargo/registry/src/github.com-1ecc6299db9ec823/bitflags-1.2.1/src/lib.rs
/home/iot_dev/Documents/Rust_prac/rust_web/simple_iot_api/target/release/deps/bitflags-3481844fb16a27e3.d: /home/iot_dev/.cargo/registry/src/github.com-1ecc6299db9ec823/bitflags-1.2.1/src/lib.rs
/home/iot_dev/.cargo/registry/src/github.com-1ecc6299db9ec823/bitflags-1.2.1/src/lib.rs:
|
D
|
// Copyright Brian Schott 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
module dfmt.indentation;
import dparse.lexer;
/**
* Returns: true if the given token type is a wrap indent type
*/
bool isWrapIndent(IdType type) pure nothrow @nogc @safe
{
return type != tok!"{" && type != tok!"case" && type != tok!"@"
&& type != tok!"]" && isOperator(type);
}
/**
* Returns: true if the given token type is a wrap indent type
*/
bool isTempIndent(IdType type) pure nothrow @nogc @safe
{
return type != tok!"{" && type != tok!"case" && type != tok!"@";
}
/**
* Stack for managing indent levels.
*/
struct IndentStack
{
/**
* Modifies the indent stack to match the state that it had at the most
* recent appearance of the given token type.
*/
int indentToMostRecent(IdType item) const
{
if (index == 0)
return -1;
size_t i = index - 1;
while (true)
{
if (arr[i] == item)
return indentSize(i);
if (i > 0)
i--;
else
return -1;
}
}
int wrapIndents() const pure nothrow @property
{
if (index == 0)
return 0;
int tempIndentCount = 0;
for (size_t i = index; i > 0; i--)
{
if (!isWrapIndent(arr[i - 1]) && arr[i - 1] != tok!"]")
break;
tempIndentCount++;
}
return tempIndentCount;
}
/**
* Pushes the given indent type on to the stack.
*/
void push(IdType item) pure nothrow
{
arr[index] = item;
index = index + 1 == arr.length ? index : index + 1;
}
/**
* Pops the top indent from the stack.
*/
void pop() pure nothrow
{
index = index == 0 ? index : index - 1;
}
/**
* Pops all wrapping indents from the top of the stack.
*/
void popWrapIndents() pure nothrow @safe @nogc
{
while (index > 0 && isWrapIndent(arr[index - 1]))
index--;
}
/**
* Pops all temporary indents from the top of the stack.
*/
void popTempIndents() pure nothrow @safe @nogc
{
while (index > 0 && isTempIndent(arr[index - 1]))
index--;
}
/**
* Returns: `true` if the top of the indent stack is the given indent type.
*/
bool topIs(IdType type) const pure nothrow @safe @nogc
{
return index > 0 && index <= arr.length && arr[index - 1] == type;
}
/**
* Returns: `true` if the top of the indent stack is a temporary indent
*/
bool topIsTemp()
{
return index > 0 && index <= arr.length && isTempIndent(arr[index - 1]);
}
/**
* Returns: `true` if the top of the indent stack is a wrapping indent
*/
bool topIsWrap()
{
return index > 0 && index <= arr.length && isWrapIndent(arr[index - 1]);
}
/**
* Returns: `true` if the top of the indent stack is one of the given token
* types.
*/
bool topIsOneOf(IdType[] types...) const pure nothrow @safe @nogc
{
if (index == 0)
return false;
immutable topType = arr[index - 1];
foreach (t; types)
if (t == topType)
return true;
return false;
}
IdType top() const pure nothrow @property @safe @nogc
{
return arr[index - 1];
}
int indentLevel() const pure nothrow @property @safe @nogc
{
return indentSize();
}
int length() const pure nothrow @property @safe @nogc
{
return cast(int) index;
}
private:
size_t index;
IdType[256] arr;
int indentSize(const size_t k = size_t.max) const pure nothrow @safe @nogc
{
if (index == 0 || k == 0)
return 0;
immutable size_t j = k == size_t.max ? index : k;
int size = 0;
foreach (i; 0 .. j)
{
if (i + 1 < index)
{
if (arr[i] == tok!"]")
continue;
immutable bool currentIsTemp = isTempIndent(arr[i]);
immutable bool nextIsTemp = isTempIndent(arr[i + 1]);
immutable bool nextIsSwitch = arr[i + 1] == tok!"switch";
if (currentIsTemp && (!nextIsTemp || nextIsSwitch))
continue;
}
size++;
}
return size;
}
}
unittest
{
IndentStack stack;
stack.push(tok!"{");
assert(stack.length == 1);
assert(stack.indentLevel == 1);
stack.pop();
assert(stack.length == 0);
assert(stack.indentLevel == 0);
stack.push(tok!"if");
assert(stack.topIsTemp());
stack.popTempIndents();
assert(stack.length == 0);
}
|
D
|
module nvimhost.client;
alias Buffer = int;
alias Window = int;
alias Tabpage = int;
alias NullInt = int;
enum MsgPackNullValue = 0xc0;
enum NeoExtType {
Buffer,
Window,
Tabpage
}
enum MsgKind {
request = 0,
response = 1,
notify = 2,
}
struct Msg(T...) {
import std.typecons;
int kind;
ulong id;
string method;
Tuple!(T) args;
}
struct MsgAsync(T...) {
import std.typecons;
int kind;
string method;
Tuple!(T) args;
}
struct MsgResponse(T) {
int kind;
ulong id;
NullInt nullInt;
T ret;
}
struct MsgVariant {
import std.typecons;
import std.variant;
int kind;
ulong id;
string method;
Variant[] args;
}
enum MethodType {NvimFunc};
struct MethodInfo {
MethodType type;
string name;
}
struct NvimClient {
import std.socket;
import std.process : environment;
import std.typecons;
import core.time;
import core.thread;
import std.concurrency : thisTid, Tid, send, receiveOnly;
import std.experimental.logger;
import vibe.core.net;
import eventcore.driver : IOMode;
import nvimhost.util : genSrcAddr;
public:
string nvimAddr;
bool logEnabled;
private:
// Client main async connection
TCPConnection conn;
NetworkAddress netAddr;
string srcAddr;
immutable bufferSize = 4096;
static ubyte[bufferSize] buffer;
/// Msgpack ID counter only used for synchronous messages.
ulong msgId = 2;
/**
Replace nulls with a default value to facilitate unpacking.
*/
void replaceNulls(ubyte[] array, ubyte newByte) {
foreach (ref item; array) {
if (item == MsgPackNullValue) {
item = 0x0;
}
}
}
unittest {
auto n = NvimClient();
ubyte[] arr = [0, 1, 2, MsgPackNullValue, 3, MsgPackNullValue];
n.replaceNulls(arr, 0);
assert(arr == [0, 1, 2, 0, 3, 0]);
}
/**
Convert ubytes arry to int
*/
int uBytesToInt(ubyte[] arr) const {
int value = 0;
for (size_t i = 0; i < arr.length; ++i) {
value += arr[i] << (8 * (arr.length - 1 - i));
}
return value;
}
unittest {
auto n = NvimClient();
assert(n.uBytesToInt([1, 0]) == 256);
assert(n.uBytesToInt([1, 1, 0]) == 65792);
assert(n.uBytesToInt([1]) == 1);
}
/**
Make a generic RPC call to Nvim. If the struct is MsgAsync it's
async, and the message is sent and no reply is ever received back (it's like
fire and forget). If it's sync (Msg struct), then Nvim will send a reply.
*/
auto callRPC(Ret = int, Struct)(Struct s) {
import msgpack;
import std.string : indexOf;
// connect if not connected yet
if (netAddr.family != AddressFamily.UNIX) {
this.connect();
}
auto packed = pack(s);
conn.write(packed, IOMode.once);
static if (indexOf(Struct.stringof, "MsgAsync!") != -1) {
tracef(logEnabled, "Sent async request data:\n%(%x %)", packed);
return 0;
} else {
tracef(logEnabled, "Sending request %d: method: %s \n%(%x %)", s.id, s.method, packed);
size_t nBytes = bufferSize;
ubyte[] data;
do {
nBytes = conn.read(buffer, IOMode.once);
tracef("Received nBytes %d", nBytes);
data ~= buffer[0 .. nBytes];
}
while (nBytes >= bufferSize);
tracef(logEnabled, "Received response (pre-unpack) :\n%(%x %)", data);
replaceNulls(data, NullInt.init);
auto unpacked = unpack!(MsgResponse!Ret)(data);
tracef(logEnabled, "Received response (unpacked bytes replaced) %d:\n%(%x %)", unpacked.id, data);
static if (Ret.stringof == "ExtValue[]") {
if (unpacked.ret.length) {
int[] nums;
logf(logEnabled, "ExtType request %d:%s\n", unpacked.id, unpacked.ret);
foreach (item; unpacked.ret) {
if (item.data.length > 1) {
nums ~= uBytesToInt(item.data[1 .. $]);
} else {
nums ~= uBytesToInt(item.data);
}
}
return nums;
}
} else static if (Ret.stringof == "ExtValue") {
auto item = unpacked.ret;
int num;
if (item.data.length > 1) {
num = uBytesToInt(item.data[1 .. $]);
} else {
num = uBytesToInt(item.data);
}
return num;
} else {
return unpacked.ret;
}
}
assert(0);
}
unittest {
auto n = NvimClient();
auto s = n.inspectMsgKind([0x94, 0x01, 0x01, MsgPackNullValue]);
assert(s.id == 0x01 && s.kind == MsgKind.response);
s = n.inspectMsgKind([0x94, 0x02, MsgPackNullValue]);
assert(s.kind == MsgKind.notify);
s = n.inspectMsgKind([0x94, 0x00, 0x02, MsgPackNullValue]);
assert(s.id == 0x02 && s.kind == MsgKind.request);
// 0x66 is the letter f
s = n.inspectMsgKind([0x94, 0x00, 0x03, 0xa2, 0x66, 0x66, 0x90]);
s = n.inspectMsgKind([0x94, 0x00, 0x03, 0xa2, 0x66, 0x66, 0x92, 0x1, 0xa1, 0x66]);
assert(s.id == 0x03 && s.kind == MsgKind.request && s.method == "ff" && s.args[0] == 1 && s.args[1] == "f");
}
public:
/**
Release resources.
*/
void close() {
import std.file : exists, remove;
if (netAddr.family == AddressFamily.UNIX) {
conn.close();
}
if (srcAddr.length && exists(srcAddr)) {
remove(srcAddr);
}
}
/**
Enable logging.
*/
void enableLog() {
if (environment.get("NVIMHOST_LOG")) {
logEnabled = true;
}
// if this env var is not defined it'll log to stderr
string logFile = environment.get("NVIMHOST_LOG_FILE");
if (logFile) {
logEnabled = true;
sharedLog = new FileLogger(logFile);
}
}
~this(){
close();
}
/**
Decode Nvim request/notifications method strings names, which has this format:
pluginName:function:functionName
pluginName:command:commandName
*/
MethodInfo decodeMethod(string methodName) {
import std.array;
auto res = methodName.split(":");
if (res.length != 3) {
throw new Exception("The methodName is supposed to match this regex .+:function|command:.+");
}
switch(res[1]) {
case "function":
return MethodInfo(MethodType.NvimFunc, res[2]);
default:
throw new Exception("Unsupported type received: " ~ res[1]);
}
}
unittest {
auto c = NvimClient();
auto res = c.decodeMethod("pluginName:function:SomeFunction");
assert(res.type == MethodType.NvimFunc && res.name == "SomeFunction");
}
/**
Inspect the first two bytes of the serialized message to figure out message type of Nvim.
*/
auto inspectMsgKind(ubyte[] arr) {
import msgpack;
import std.variant;
if (arr.length < 3) {
assert(false, "Truncated message received.");
}
auto unpacker = StreamingUnpacker(cast(ubyte[]) null);
unpacker.feed(arr);
unpacker.execute();
int msgType = -1;
int id;
string method;
auto myT = tuple();
Variant[] varArgs;
/**
Recursively unpacks array lists.
Nvim wraps funcs and cmd args via RPC in nested lists issue #1929
*/
void unpackArray(ref Variant[] varArr, Value[] arr) {
Variant arg;
foreach (item; arr) {
switch(item.type) {
// chances are for plugins cast(int) will be enough for most cases
case Value.Type.unsigned:
arg = cast(int) item.via.uinteger;
varArr ~= arg;
break;
case Value.Type.signed:
arg = cast(int) item.via.integer;
varArr ~= arg;
break;
case Value.Type.boolean:
arg = item.via.boolean;
varArr ~= arg;
break;
case Value.Type.raw:
arg = cast(string) item.via.raw;
varArr ~= arg;
break;
case Value.Type.floating:
arg = item.via.floating;
varArr ~= arg;
break;
case Value.Type.array:
tracef(logEnabled, "nested array");
unpackArray(varArr, item.via.array);
break;
default:
errorf("Nested type %s is not supported yet", item.type);
break;
}
}
}
foreach (unpacked; unpacker.purge()) {
if (unpacked.type == Value.Type.unsigned) {
if (unpacked.type == Value.Type.unsigned ) {
if (msgType == -1) {
msgType = cast(int) unpacked.via.uinteger;
} else {
id = cast(int) unpacked.via.uinteger;
}
}
} else if (unpacked.type == Value.Type.raw) {
method = cast (string)unpacked.via.raw;
} else if (unpacked.type == Value.Type.array) {
unpackArray(varArgs, unpacked.via.array);
} else if (unpacked.type == Value.Type.nil) {
// incoming nulls don't matter.
continue;
} else {
errorf("Type %s is not supported as a response param yet", unpacked.type);
}
}
auto res = MsgVariant(msgType, id, method, varArgs);
assert(msgType >= 0, "Couldn't parse message type.");
assert(id >= 0, "Couldn't parse message id.");
return res;
}
/**
Asynchronous call returns immediatetly after serialializing the data over RPC.
*/
auto callAsync(Ret, T...)(string cmd, T args) if (Ret.stringof == "void") {
import std.traits;
auto myT = tuple(args);
auto msgAsync = MsgAsync!(myT.Types)(MsgKind.notify, cmd, myT);
callRPC!(Ret)(msgAsync);
}
/**
Synchronous call.
*/
auto call(Ret = int, T...)(string cmd, T args) {
import std.traits;
auto myT = tuple(args);
auto msg = Msg!(myT.Types)(MsgKind.request, ++msgId, cmd, myT);
static if (Ret.stringof == "void") {
auto res = callRPC!(int)(msg);
} else {
return callRPC!(Ret)(msg);
}
}
/**
Open an async TCP connection handler to Nvim using UnixAddress.
If NVIM_LISTEN_ADDRESS environment variable is not set throws
NvimListenAddressException.
*/
void connect() {
import std.path;
this.nvimAddr = environment.get("NVIM_LISTEN_ADDRESS", "");
if (nvimAddr == "") {
throw new NvimListenAddressException("Couldn't get NVIM_LISTEN_ADDRESS, is nvim running?");
}
auto unixAddr = new UnixAddress(nvimAddr);
netAddr = NetworkAddress(unixAddr);
srcAddr = genSrcAddr();
auto netSrcAddr = NetworkAddress(new UnixAddress(srcAddr));
conn = connectTCP(netAddr, netSrcAddr);
conn.keepAlive(true);
tracef(logEnabled, "Main thread connected to nvim");
}
}
class NvimListenAddressException : Exception {
this(string msg, string file = __FILE__, size_t line = __LINE__) {
super(msg, file, line);
}
}
|
D
|
/*******************************************************************************
* Copyright (c) 2000, 2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Port to the D programming language:
* Frank Benoit <benoit@tionex.de>
*******************************************************************************/
module dwtx.jface.text.rules.WhitespaceRule;
import dwtx.jface.text.rules.FastPartitioner; // packageimport
import dwtx.jface.text.rules.ITokenScanner; // packageimport
import dwtx.jface.text.rules.Token; // packageimport
import dwtx.jface.text.rules.RuleBasedScanner; // packageimport
import dwtx.jface.text.rules.EndOfLineRule; // packageimport
import dwtx.jface.text.rules.WordRule; // packageimport
import dwtx.jface.text.rules.WordPatternRule; // packageimport
import dwtx.jface.text.rules.IPredicateRule; // packageimport
import dwtx.jface.text.rules.DefaultPartitioner; // packageimport
import dwtx.jface.text.rules.NumberRule; // packageimport
import dwtx.jface.text.rules.SingleLineRule; // packageimport
import dwtx.jface.text.rules.PatternRule; // packageimport
import dwtx.jface.text.rules.RuleBasedDamagerRepairer; // packageimport
import dwtx.jface.text.rules.ICharacterScanner; // packageimport
import dwtx.jface.text.rules.IRule; // packageimport
import dwtx.jface.text.rules.DefaultDamagerRepairer; // packageimport
import dwtx.jface.text.rules.IToken; // packageimport
import dwtx.jface.text.rules.IPartitionTokenScanner; // packageimport
import dwtx.jface.text.rules.MultiLineRule; // packageimport
import dwtx.jface.text.rules.RuleBasedPartitioner; // packageimport
import dwtx.jface.text.rules.RuleBasedPartitionScanner; // packageimport
import dwtx.jface.text.rules.BufferedRuleBasedScanner; // packageimport
import dwtx.jface.text.rules.IWhitespaceDetector; // packageimport
import dwt.dwthelper.utils;
import dwtx.core.runtime.Assert;
/**
* An implementation of <code>IRule</code> capable of detecting whitespace.
* A whitespace rule uses a whitespace detector in order to find out which
* characters are whitespace characters.
*
* @see IWhitespaceDetector
*/
public class WhitespaceRule : IRule {
/** The whitespace detector used by this rule */
protected IWhitespaceDetector fDetector;
/**
* Creates a rule which, with the help of an
* whitespace detector, will return a whitespace
* token when a whitespace is detected.
*
* @param detector the rule's whitespace detector, may not be <code>null</code>
*/
public this(IWhitespaceDetector detector) {
Assert.isNotNull(cast(Object)detector);
fDetector= detector;
}
/*
* @see IRule#evaluate(ICharacterScanner)
*/
public IToken evaluate(ICharacterScanner scanner) {
int c= scanner.read();
if (fDetector.isWhitespace(cast(char) c)) {
do {
c= scanner.read();
} while (fDetector.isWhitespace(cast(char) c));
scanner.unread();
return Token.WHITESPACE;
}
scanner.unread();
return Token.UNDEFINED;
}
}
|
D
|
// Copyright Michael D. Parker 2018.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
module bindbc.sdl.bind.sdlvulkan;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
import bindbc.sdl.bind.sdlvideo : SDL_Window;
version(BindSDL_Static) {
extern(C) @nogc nothrow {
static if(sdlSupport >= SDLSupport.sdl206) {
SDL_bool SDL_Vulkan_CreateSurface(SDL_Window*,void*,void*);
void SDL_Vulkan_GetDrawableSize(SDL_Window*,int*,int*);
SDL_bool SDL_Vulkan_GetInstanceExtensions(SDL_Window*,uint*,const(char)**);
void* SDL_Vulkan_GetVkGetInstanceProcAddr();
int SDL_Vulkan_LoadLibrary(const(char)*);
void SDL_Vulkan_UnloadLibrary();
}
}
}
else {
static if(sdlSupport >= SDLSupport.sdl206) {
extern(C) @nogc nothrow {
alias pSDL_Vulkan_CreateSurface = SDL_bool function(SDL_Window*,void*,void*);
alias pSDL_Vulkan_GetDrawableSize = void function(SDL_Window*,int*,int*);
alias pSDL_Vulkan_GetInstanceExtensions = SDL_bool function(SDL_Window*,uint*,const(char)**);
alias pSDL_Vulkan_GetVkGetInstanceProcAddr = void* function();
alias pSDL_Vulkan_LoadLibrary = int function(const(char)*);
alias pSDL_Vulkan_UnloadLibrary = void function();
}
__gshared {
pSDL_Vulkan_CreateSurface SDL_Vulkan_CreateSurface;
pSDL_Vulkan_GetDrawableSize SDL_Vulkan_GetDrawableSize;
pSDL_Vulkan_GetInstanceExtensions SDL_Vulkan_GetInstanceExtensions;
pSDL_Vulkan_GetVkGetInstanceProcAddr SDL_Vulkan_GetVkGetInstanceProcAddr;
pSDL_Vulkan_LoadLibrary SDL_Vulkan_LoadLibrary;
pSDL_Vulkan_UnloadLibrary SDL_Vulkan_UnloadLibrary;
}
}
}
|
D
|
/*
TEST_OUTPUT:
---
fail_compilation/fail12255.d(29): Error: AA key type `SC1` does not have `bool opEquals(ref const SC1) const`
fail_compilation/fail12255.d(30): Error: AA key type `SC2` does not support const equality
fail_compilation/fail12255.d(35): Error: AA key type `SD1` should have `size_t toHash() const nothrow @safe` if `opEquals` defined
fail_compilation/fail12255.d(36): Error: AA key type `SD2` supports const equality but doesn't support const hashing
fail_compilation/fail12255.d(40): Error: AA key type `SE1` should have `size_t toHash() const nothrow @safe` if `opEquals` defined
fail_compilation/fail12255.d(41): Error: AA key type `SE2` supports const equality but doesn't support const hashing
---
*/
void main()
{
/* Key comparison and hashing are based on object bit representation,
* and they fully supported in runtime (TypeInfo.equals and TypeInfo.getHash)
*/
int[SA1] a1; // OK
int[SA2] a2; // OK
/* If only toHash is defined, AA assumes that is customized object hashing.
*/
int[SB1] b1; // OK
int[SB2] b2; // OK
/* If key does not support const equality,
* it is disallowed, because TypeInfo.equals will throw Error.
*/
int[SC1] c1; // NG
int[SC2] c2; // NG
/* If opEquals defined for const equality, corresponding toHash method
* is required to guarantee (a != b || a.toHash() == b.toHash()).
*/
int[SD1] d1; // NG
int[SD2] d2; // NG
/* same as SD cases
*/
int[SE1] e1; // NG
int[SE2] e2; // NG
}
struct SA1 { int val; }
struct SA2 { SA1 s; }
struct SB1
{
// AA assumes this is specialized hashing (?)
size_t toHash() const nothrow @safe { return 0; }
}
struct SB2
{
SB1 s;
// implicit generated toHash() calls s.toHash().
}
struct SC1
{
// does not support const equality
bool opEquals(typeof(this)) /*const*/ { return true; }
}
struct SC2
{
SC1 s;
}
struct SD1
{
// Supports const equality, but
// does not have corresponding toHash()
bool opEquals(typeof(this)) const { return true; }
}
struct SD2
{
SD1 s;
}
struct SE1
{
// Supports const equality, but
// does not have corresponding valid toHash()
bool opEquals(typeof(this)) const { return true; }
size_t toHash() @system { return 0; }
}
struct SE2
{
SE1 s;
}
/*
TEST_OUTPUT:
---
fail_compilation/fail12255.d(108): Error: bottom of AA key type `SC1` does not have `bool opEquals(ref const SC1) const`
fail_compilation/fail12255.d(109): Error: bottom of AA key type `SC2` does not support const equality
fail_compilation/fail12255.d(110): Error: bottom of AA key type `SD1` should have `size_t toHash() const nothrow @safe` if `opEquals` defined
fail_compilation/fail12255.d(111): Error: bottom of AA key type `SD2` supports const equality but doesn't support const hashing
fail_compilation/fail12255.d(112): Error: bottom of AA key type `SE1` should have `size_t toHash() const nothrow @safe` if `opEquals` defined
fail_compilation/fail12255.d(113): Error: bottom of AA key type `SE2` supports const equality but doesn't support const hashing
---
*/
void testSArray()
{
int[SA1[1]] a1; // OK
int[SA2[1]] a2; // OK
int[SB1[1]] b1; // OK
int[SB2[1]] b2; // OK
int[SC1[1]] c1; // NG
int[SC2[1]] c2; // NG
int[SD1[1]] d1; // NG
int[SD2[1]] d2; // NG
int[SE1[1]] e1; // NG
int[SE2[1]] e2; // NG
}
/*
TEST_OUTPUT:
---
fail_compilation/fail12255.d(133): Error: bottom of AA key type `SC1` does not have `bool opEquals(ref const SC1) const`
fail_compilation/fail12255.d(134): Error: bottom of AA key type `SC2` does not support const equality
fail_compilation/fail12255.d(135): Error: bottom of AA key type `SD1` should have `size_t toHash() const nothrow @safe` if `opEquals` defined
fail_compilation/fail12255.d(136): Error: bottom of AA key type `SD2` supports const equality but doesn't support const hashing
fail_compilation/fail12255.d(137): Error: bottom of AA key type `SE1` should have `size_t toHash() const nothrow @safe` if `opEquals` defined
fail_compilation/fail12255.d(138): Error: bottom of AA key type `SE2` supports const equality but doesn't support const hashing
---
*/
void testDArray()
{
int[SA1[]] a1; // OK
int[SA2[]] a2; // OK
int[SB1[]] b1; // OK
int[SB2[]] b2; // OK
int[SC1[]] c1; // NG
int[SC2[]] c2; // NG
int[SD1[]] d1; // NG
int[SD2[]] d2; // NG
int[SE1[]] e1; // NG
int[SE2[]] e2; // NG
}
|
D
|
/Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/Objects-normal/x86_64/customview.o : /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/ViewController.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/testViewController.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/AppDelegate.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/customview.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/DerivedSources/CoreDataGenerated/CoreDataSampleApp/Task+CoreDataClass.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/DerivedSources/CoreDataGenerated/CoreDataSampleApp/Task+CoreDataProperties.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/DerivedSources/CoreDataGenerated/CoreDataSampleApp/CoreDataSampleApp+CoreDataModel.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreData.swiftmodule
/Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/Objects-normal/x86_64/customview~partial.swiftmodule : /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/ViewController.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/testViewController.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/AppDelegate.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/customview.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/DerivedSources/CoreDataGenerated/CoreDataSampleApp/Task+CoreDataClass.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/DerivedSources/CoreDataGenerated/CoreDataSampleApp/Task+CoreDataProperties.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/DerivedSources/CoreDataGenerated/CoreDataSampleApp/CoreDataSampleApp+CoreDataModel.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreData.swiftmodule
/Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/Objects-normal/x86_64/customview~partial.swiftdoc : /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/ViewController.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/testViewController.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/AppDelegate.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/CoreDataSampleApp/customview.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/DerivedSources/CoreDataGenerated/CoreDataSampleApp/Task+CoreDataClass.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/DerivedSources/CoreDataGenerated/CoreDataSampleApp/Task+CoreDataProperties.swift /Users/apple-1/Documents/xCode/CoreDataSampleApp/Build/Intermediates/CoreDataSampleApp.build/Debug-iphonesimulator/CoreDataSampleApp.build/DerivedSources/CoreDataGenerated/CoreDataSampleApp/CoreDataSampleApp+CoreDataModel.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreData.swiftmodule
|
D
|
/Users/oslo/code/swift_vapor_server/.build/debug/SocksCore.build/Error.swift.o : /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Address+C.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Address.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Bytes.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Conversions.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Error.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/FDSet.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/InternetSocket.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Pipe.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Select.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Socket.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/SocketOptions+Deprecated.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/SocketOptions.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/TCPSocket.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Types.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/UDPSocket.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule
/Users/oslo/code/swift_vapor_server/.build/debug/SocksCore.build/Error~partial.swiftmodule : /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Address+C.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Address.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Bytes.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Conversions.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Error.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/FDSet.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/InternetSocket.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Pipe.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Select.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Socket.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/SocketOptions+Deprecated.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/SocketOptions.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/TCPSocket.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Types.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/UDPSocket.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule
/Users/oslo/code/swift_vapor_server/.build/debug/SocksCore.build/Error~partial.swiftdoc : /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Address+C.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Address.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Bytes.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Conversions.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Error.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/FDSet.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/InternetSocket.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Pipe.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Select.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Socket.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/SocketOptions+Deprecated.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/SocketOptions.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/TCPSocket.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/Types.swift /Users/oslo/code/swift_vapor_server/Packages/Socks-1.2.7/Sources/SocksCore/UDPSocket.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule
|
D
|
// *************************************************************************
// Kapitel 1
// *************************************************************************
// *************************************************************************
// EXIT
// *************************************************************************
INSTANCE Info_ReisBau_4_EXIT(C_INFO)
{
// npc wird in B_AssignAmbientInfos_ReisBau_4 (s.u.) jeweils gesetzt
nr = 999;
condition = Info_ReisBau_4_EXIT_Condition;
information = Info_ReisBau_4_EXIT_Info;
permanent = 1;
description = "ENDE";
};
FUNC INT Info_ReisBau_4_EXIT_Condition()
{
return 1;
};
FUNC VOID Info_ReisBau_4_EXIT_Info()
{
AI_StopProcessInfos (self);
};
// *************************************************************************
// Wichtige Personen
// *************************************************************************
INSTANCE Info_ReisBau_4_WichtigePersonen(C_INFO)
{
nr = 3;
condition = Info_ReisBau_4_WichtigePersonen_Condition;
information = Info_ReisBau_4_WichtigePersonen_Info;
permanent = 1;
description = "Habt ihr einen Anführer?";
};
FUNC INT Info_ReisBau_4_WichtigePersonen_Condition()
{
return 1;
};
FUNC VOID Info_ReisBau_4_WichtigePersonen_Info()
{
AI_Output(hero,self,"Info_ReisBau_4_WichtigePersonen_15_00"); //Habt ihr einen Anführer?
AI_Output(self,hero,"Info_ReisBau_4_WichtigePersonen_04_01"); //Der Reislord ist so was wie unser Anführer. Aber die meisten arbeiten nur aus Angst vor ihm und seinen Schlägern.
AI_Output(self,hero,"Info_ReisBau_4_WichtigePersonen_04_02"); //Bei mir sieht das anders aus. Ich hab' schon ein paar Jahre auf dem Buckel und keine Lust mehr, mich mit den Söldnern im Lager rumzuschlagen ... Die Reisfelder sind genau das Richtige für mich.
};
// *************************************************************************
// Das Lager (Orts-Infos)
// *************************************************************************
INSTANCE Info_ReisBau_4_DasLager(C_INFO)
{
nr = 2;
condition = Info_ReisBau_4_DasLager_Condition;
information = Info_ReisBau_4_DasLager_Info;
permanent = 1;
description = "Was muß ich über diesen Ort wissen?";
};
FUNC INT Info_ReisBau_4_DasLager_Condition()
{
return 1;
};
FUNC VOID Info_ReisBau_4_DasLager_Info()
{
AI_Output(hero,self,"Info_ReisBau_4_DasLager_15_00"); //Was muss ich über diesen Ort wissen?
AI_Output(self,hero,"Info_ReisBau_4_DasLager_04_01"); //Sei vorsichtig, wenn du ins Lager gehst, Junge! Da laufen so einige Halsabschneider rum, die einem Neuen wie dir an die Kehle wollen.
};
// *************************************************************************
// Die Lage
// *************************************************************************
INSTANCE Info_ReisBau_4_DieLage(C_INFO) // E1
{
nr = 1;
condition = Info_ReisBau_4_DieLage_Condition;
information = Info_ReisBau_4_DieLage_Info;
permanent = 1;
description = "Wie läuft's denn so?";
};
FUNC INT Info_ReisBau_4_DieLage_Condition()
{
return 1;
};
FUNC VOID Info_ReisBau_4_DieLage_Info()
{
AI_Output(hero,self,"Info_ReisBau_4_DieLage_15_00"); //Wie läuft's denn so?
AI_Output(self,hero,"Info_ReisBau_4_DieLage_04_01"); //Gibt 'ne Menge zu tun. Wir brauchen viel Reis, um die Leute hier alle ernähren zu können.
};
INSTANCE Info_Mod_ReisBau_4_Pickpocket (C_INFO)
{
nr = 6;
condition = Info_Mod_ReisBau_4_Pickpocket_Condition;
information = Info_Mod_ReisBau_4_Pickpocket_Info;
permanent = 1;
important = 0;
description = Pickpocket_30;
};
FUNC INT Info_Mod_ReisBau_4_Pickpocket_Condition()
{
C_Beklauen (r_max(30), ItMi_Gold, 10 + r_max(5));
};
FUNC VOID Info_Mod_ReisBau_4_Pickpocket_Info()
{
Info_ClearChoices (Info_Mod_ReisBau_4_Pickpocket);
Info_AddChoice (Info_Mod_ReisBau_4_Pickpocket, DIALOG_BACK, Info_Mod_ReisBau_4_Pickpocket_BACK);
Info_AddChoice (Info_Mod_ReisBau_4_Pickpocket, DIALOG_PICKPOCKET, Info_Mod_ReisBau_4_Pickpocket_DoIt);
};
FUNC VOID Info_Mod_ReisBau_4_Pickpocket_BACK()
{
Info_ClearChoices (Info_Mod_ReisBau_4_Pickpocket);
};
FUNC VOID Info_Mod_ReisBau_4_Pickpocket_DoIt()
{
if (B_Beklauen() == TRUE)
{
Info_ClearChoices (Info_Mod_ReisBau_4_Pickpocket);
}
else
{
Info_ClearChoices (Info_Mod_ReisBau_4_Pickpocket);
Info_AddChoice (Info_Mod_ReisBau_4_Pickpocket, DIALOG_PP_BESCHIMPFEN, Info_Mod_ReisBau_4_Pickpocket_Beschimpfen);
Info_AddChoice (Info_Mod_ReisBau_4_Pickpocket, DIALOG_PP_BESTECHUNG, Info_Mod_ReisBau_4_Pickpocket_Bestechung);
Info_AddChoice (Info_Mod_ReisBau_4_Pickpocket, DIALOG_PP_HERAUSREDEN, Info_Mod_ReisBau_4_Pickpocket_Herausreden);
};
};
FUNC VOID Info_Mod_ReisBau_4_Pickpocket_Beschimpfen()
{
B_Say (hero, self, "$PICKPOCKET_BESCHIMPFEN");
B_Say (self, hero, "$DIRTYTHIEF");
Info_ClearChoices (Info_Mod_ReisBau_4_Pickpocket);
AI_StopProcessInfos (self);
B_Attack (self, hero, AR_Theft, 1);
};
FUNC VOID Info_Mod_ReisBau_4_Pickpocket_Bestechung()
{
B_Say (hero, self, "$PICKPOCKET_BESTECHUNG");
var int rnd; rnd = r_max(99);
if (rnd < 25)
|| ((rnd >= 25) && (rnd < 50) && (Npc_HasItems(hero, ItMi_Gold) < 50))
|| ((rnd >= 50) && (rnd < 75) && (Npc_HasItems(hero, ItMi_Gold) < 100))
|| ((rnd >= 75) && (rnd < 100) && (Npc_HasItems(hero, ItMi_Gold) < 200))
{
B_Say (self, hero, "$DIRTYTHIEF");
Info_ClearChoices (Info_Mod_ReisBau_4_Pickpocket);
AI_StopProcessInfos (self);
B_Attack (self, hero, AR_Theft, 1);
}
else
{
if (rnd >= 75)
{
B_GiveInvItems (hero, self, ItMi_Gold, 200);
}
else if (rnd >= 50)
{
B_GiveInvItems (hero, self, ItMi_Gold, 100);
}
else if (rnd >= 25)
{
B_GiveInvItems (hero, self, ItMi_Gold, 50);
};
B_Say (self, hero, "$PICKPOCKET_BESTECHUNG_01");
Info_ClearChoices (Info_Mod_ReisBau_4_Pickpocket);
AI_StopProcessInfos (self);
};
};
FUNC VOID Info_Mod_ReisBau_4_Pickpocket_Herausreden()
{
B_Say (hero, self, "$PICKPOCKET_HERAUSREDEN");
if (r_max(99) < Mod_Verhandlungsgeschick)
{
B_Say (self, hero, "$PICKPOCKET_HERAUSREDEN_01");
Info_ClearChoices (Info_Mod_ReisBau_4_Pickpocket);
}
else
{
B_Say (self, hero, "$PICKPOCKET_HERAUSREDEN_02");
};
};
// *************************************************************************
// -------------------------------------------------------------------------
FUNC VOID B_AssignAmbientInfos_ReisBau_4(var c_NPC slf)
{
Info_ReisBau_4_EXIT.npc = Hlp_GetInstanceID(slf);
Info_ReisBau_4_WichtigePersonen.npc = Hlp_GetInstanceID(slf);
Info_ReisBau_4_DasLager.npc = Hlp_GetInstanceID(slf);
Info_ReisBau_4_DieLage.npc = Hlp_GetInstanceID(slf);
Info_Mod_ReisBau_4_Pickpocket.npc = Hlp_GetInstanceID(slf);
};
|
D
|
// Copyright Jernej Krempuš 2012
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
module pfft.avx_double;
import core.simd;
import pfft.fft_impl;
version(LDC)
{
import pfft.avx_declarations;
}
else version(GNU)
{
import gcc.builtins;
template shuf_mask(int a3, int a2, int a1, int a0)
{
enum shuf_mask = a0 | (a1<<2) | (a2<<4) | (a3<<6);
}
double4 interleave128_lo_d(double4 a, double4 b)
{
return __builtin_ia32_vperm2f128_pd256(a, b, shuf_mask!(0,2,0,0));
}
double4 interleave128_hi_d(double4 a, double4 b)
{
return __builtin_ia32_vperm2f128_pd256(a, b, shuf_mask!(0,3,0,1));
}
alias __builtin_ia32_unpcklpd256 unpcklpd;
alias __builtin_ia32_unpckhpd256 unpckhpd;
alias __builtin_ia32_loadupd256 loadupd;
alias __builtin_ia32_storeupd256 storeupd;
}
struct Vector
{
alias double4 vec;
alias double T;
enum vec_size = 4;
enum log2_bitreverse_chunk_size = 2;
static auto v(T* p){ return cast(vec*) p; }
static void complex_array_to_real_imag_vec(int n)(T* arr, ref vec rr, ref vec ri)
{
static if (n == 4)
deinterleave!4(v(arr)[0], v(arr)[1], rr, ri);
else static if(n == 2)
{
vec a = *v(arr);
rr = unpcklpd(a, a);
ri = unpckhpd(a, a);
}
else
static assert(0);
}
static void deinterleave(int interleaved)(vec a0, vec a1, ref vec r0, ref vec r1)
{
static if(interleaved == 4)
{
vec b0, b1;
deinterleave!2(a0, a1, b0, b1);
r0 = unpcklpd(b0, b1);
r1 = unpckhpd(b0, b1);
}
else static if(interleaved == 2)
{
r0 = interleave128_lo_d(a0, a1);
r1 = interleave128_hi_d(a0, a1);
}
else
static assert(0);
}
static void interleave(int interleaved)(vec a0, vec a1, ref vec r0, ref vec r1)
{
static if(interleaved == 4)
{
vec b0, b1;
b0 = unpcklpd(a0, a1);
b1 = unpckhpd(a0, a1);
deinterleave!2(b0, b1, r0, r1);
}
else static if(interleaved == 2)
deinterleave!2(a0, a1, r0, r1);
else
static assert(0);
}
static void bit_reverse_swap(double * p0, double * p1, size_t m)
{
vec a0, a1, a2, a3, b0, b1, b2, b3;
a0 = *v(p0 + 0 * m);
a1 = *v(p0 + 1 * m);
a2 = *v(p0 + 2 * m);
a3 = *v(p0 + 3 * m);
b0 = unpcklpd(a0, a2);
b2 = unpckhpd(a0, a2);
b1 = unpcklpd(a1, a3);
b3 = unpckhpd(a1, a3);
a0 = interleave128_lo_d(b0, b1);
a1 = interleave128_hi_d(b0, b1);
a2 = interleave128_lo_d(b2, b3);
a3 = interleave128_hi_d(b2, b3);
b0 = *v(p1 + 0 * m);
b1 = *v(p1 + 1 * m);
b2 = *v(p1 + 2 * m);
b3 = *v(p1 + 3 * m);
*v(p1 + 0 * m) = a0;
*v(p1 + 1 * m) = a1;
*v(p1 + 2 * m) = a2;
*v(p1 + 3 * m) = a3;
a0 = unpcklpd(b0, b2);
a2 = unpckhpd(b0, b2);
a1 = unpcklpd(b1, b3);
a3 = unpckhpd(b1, b3);
b0 = interleave128_lo_d(a0, a1);
b1 = interleave128_hi_d(a0, a1);
b2 = interleave128_lo_d(a2, a3);
b3 = interleave128_hi_d(a2, a3);
*v(p0 + 0 * m) = b0;
*v(p0 + 1 * m) = b1;
*v(p0 + 2 * m) = b2;
*v(p0 + 3 * m) = b3;
}
static void bit_reverse(double * p, size_t m)
{
vec a0, a1, a2, a3, b0, b1, b2, b3;
a0 = *v(p + 0 * m);
a1 = *v(p + 1 * m);
a2 = *v(p + 2 * m);
a3 = *v(p + 3 * m);
b0 = unpcklpd(a0, a2);
b2 = unpckhpd(a0, a2);
b1 = unpcklpd(a1, a3);
b3 = unpckhpd(a1, a3);
*v(p + 0 * m) = interleave128_lo_d(b0, b1);
*v(p + 1 * m) = interleave128_hi_d(b0, b1);
*v(p + 2 * m) = interleave128_lo_d(b2, b3);
*v(p + 3 * m) = interleave128_hi_d(b2, b3);
}
static vec scalar_to_vector(T a)
{
return a;
}
static vec unaligned_load(T* p)
{
return loadupd(p);
}
static void unaligned_store(T* p, vec v)
{
storeupd(p, v);
}
static vec reverse(vec v)
{
v = __builtin_ia32_shufpd256(v, v, 0x5);
v = __builtin_ia32_vperm2f128_pd256(v, v, shuf_mask!(0,0,0,1));
return v;
}
}
struct Options
{
enum log2_bitreverse_large_chunk_size = 5;
enum large_limit = 14;
enum log2_optimal_n = 8;
enum passes_per_recursive_call = 4;
enum log2_recursive_passes_chunk_size = 4;
enum prefered_alignment = 4 * (1 << 10);
enum { fast_init };
}
|
D
|
Hello World
=== ${RESULTS_DIR}/compilable/testheader1i.di
// D import file generated from 'compilable/extra-files/header1.d'
module foo.bar;
import core.vararg;
void writeln(T...)(T)
{
}
pragma (lib, "test");
pragma (msg, "Hello World");
pragma (linkerDirective, "/DEFAULTLIB:test2");
static assert(true, "message");
alias mydbl = double;
alias fl1 = function ()
in
{
}
in (true)
out (; true)
out (r; true)
out
{
}
out(r)
{
}
do
{
return 2;
}
;
alias fl2 = function ()
in (true)
out (; true)
out (r; true)
{
return 2;
}
;
int testmain()
in
{
assert(1 + (2 + 3) == -(1 - 2 * 3));
}
out(result)
{
assert(result == 0);
}
do
{
float f = (float).infinity;
int i = cast(int)f;
writeln(i, 1, 2);
writeln(cast(int)(float).max);
assert(i == cast(int)(float).max);
assert(i == 2147483648u);
return 0;
}
struct S
{
int m;
int n;
}
template Foo(T, int V)
{
void foo(...)
{
static if (is(Object _ : X!TL, alias X, TL...))
{
}
auto x = __traits(hasMember, Object, "noMember");
auto y = is(Object : X!TL, alias X, TL...);
assert(!x && !y, "message");
S s = {1, 2};
auto a = [1, 2, 3];
auto aa = [1:1, 2:2, 3:3];
int n, m;
}
int bar(double d, int x)
{
if (d)
{
d++;
}
else
d--;
asm { naked; }
asm { mov EAX,3; }
for (;;)
{
{
d = d + 1;
}
}
for (int i = 0;
i < 10; i++)
{
{
d = i ? d + 1 : 5;
}
}
char[] s;
foreach (char c; s)
{
d *= 2;
if (d)
break;
else
continue;
}
switch (V)
{
case 1:
{
}
case 2:
{
break;
}
case 3:
{
goto case 1;
}
case 4:
{
goto default;
}
default:
{
d /= 8;
break;
}
}
enum Label
{
A,
B,
C,
}
void fswitch(Label l)
{
final switch (l)
{
case A:
{
break;
}
case B:
{
break;
}
case C:
{
break;
}
}
}
loop:
while (x)
{
x--;
if (x)
break loop;
else
continue loop;
}
do
{
x++;
}
while (x < 10);
try
{
try
{
bar(1, 2);
}
catch(Object o)
{
x++;
}
}
finally
{
x--;
}
try
{
try
bar(1, 2);
catch(Object o)
{
x++;
}
}
finally
x--;
Object o;
synchronized(o) {
x = ~x;
}
synchronized {
x = x < 3;
}
with (o)
{
toString();
}
}
}
static this();
static ~this();
nothrow pure @nogc @safe static this();
nothrow pure @nogc @safe static ~this();
nothrow pure @nogc @safe static this();
nothrow pure @nogc @safe static ~this();
nothrow pure @nogc @safe shared static this();
nothrow pure @nogc @safe shared static ~this();
nothrow pure @nogc @safe shared static this();
nothrow pure @nogc @safe shared static ~this();
interface iFoo
{
}
class xFoo : iFoo
{
}
interface iFoo2
{
}
class xFoo2 : iFoo, iFoo2
{
}
class Foo3
{
this(int a, ...)
{
}
this(int* a)
{
}
}
alias myint = int;
static notquit = 1;
class Test
{
void a()
{
}
void b()
{
}
void c()
{
}
void d()
{
}
void e()
{
}
void f()
{
}
void g()
{
}
void h()
{
}
void i()
{
}
void j()
{
}
void k()
{
}
void l()
{
}
void m()
{
}
void n()
{
}
void o()
{
}
void p()
{
}
void q()
{
}
void r()
{
}
void s()
{
}
void t()
{
}
void u()
{
}
void v()
{
}
void w()
{
}
void x()
{
}
void y()
{
}
void z()
{
}
void aa()
{
}
void bb()
{
}
void cc()
{
}
void dd()
{
}
void ee()
{
}
template A(T)
{
}
alias getHUint = A!uint;
alias getHInt = A!int;
alias getHFloat = A!float;
alias getHUlong = A!ulong;
alias getHLong = A!long;
alias getHDouble = A!double;
alias getHByte = A!byte;
alias getHUbyte = A!ubyte;
alias getHShort = A!short;
alias getHUShort = A!ushort;
alias getHReal = A!real;
alias void F();
}
void templ(T)(T val)
{
pragma (msg, "Invalid destination type.");
}
static char[] charArray = ['"', '\''];
class Point
{
auto x = 10;
uint y = 20;
}
template Foo2(bool bar)
{
void test()
{
static if (bar)
{
int i;
}
else
{
}
static if (!bar)
{
}
else
{
}
}
}
template Foo4()
{
void bar()
{
}
}
template Foo4x(T...)
{
}
class Baz4
{
mixin Foo4!() foo;
mixin Foo4x!(int, "str") foox;
alias baz = foo.bar;
}
int test(T)(T t)
{
if (auto o = cast(Object)t)
return 1;
return 0;
}
enum x6 = 1;
bool foo6(int a, int b, int c, int d)
{
return (a < b) != (c < d);
}
auto foo7(int x)
{
return 5;
}
class D8
{
}
void func8()
{
scope a = new D8;
}
T func9(T)() if (true)
{
T i;
scope(exit) i = 1;
scope(success) i = 2;
scope(failure) i = 3;
return i;
}
template V10(T)
{
void func()
{
for (int i, j = 4; i < 3; i++)
{
{
}
}
}
}
int foo11(int function() fn)
{
return fn();
}
int bar11(T)()
{
return foo11(function int()
{
return 0;
}
);
}
struct S6360
{
const pure nothrow @property long weeks1()
{
return 0;
}
const pure nothrow @property long weeks2()
{
return 0;
}
}
struct S12
{
nothrow this(int n)
{
}
nothrow this(string s)
{
}
}
struct T12
{
immutable this()(int args)
{
}
immutable this(A...)(A args)
{
}
}
import core.stdc.stdio : printf, F = FILE;
void foo6591()()
{
import core.stdc.stdio : printf, F = FILE;
}
version (unittest)
{
public {}
extern (C) {}
align {}
}
template Foo10334(T) if (Bar10334!())
{
}
template Foo10334(T) if (Bar10334!100)
{
}
template Foo10334(T) if (Bar10334!3.14)
{
}
template Foo10334(T) if (Bar10334!"str")
{
}
template Foo10334(T) if (Bar10334!1.4i)
{
}
template Foo10334(T) if (Bar10334!null)
{
}
template Foo10334(T) if (Bar10334!true)
{
}
template Foo10334(T) if (Bar10334!false)
{
}
template Foo10334(T) if (Bar10334!'A')
{
}
template Foo10334(T) if (Bar10334!int)
{
}
template Foo10334(T) if (Bar10334!string)
{
}
template Foo10334(T) if (Bar10334!wstring)
{
}
template Foo10334(T) if (Bar10334!dstring)
{
}
template Foo10334(T) if (Bar10334!this)
{
}
template Foo10334(T) if (Bar10334!([1, 2, 3]))
{
}
template Foo10334(T) if (Bar10334!(Baz10334!()))
{
}
template Foo10334(T) if (Bar10334!(Baz10334!T))
{
}
template Foo10334(T) if (Bar10334!(Baz10334!100))
{
}
template Foo10334(T) if (Bar10334!(.foo))
{
}
template Foo10334(T) if (Bar10334!(const(int)))
{
}
template Foo10334(T) if (Bar10334!(shared(T)))
{
}
template Test10334(T...)
{
}
mixin Test10334!int a;
mixin Test10334!(int, long) b;
mixin Test10334!"str" c;
auto clamp12266a(T1, T2, T3)(T1 x, T2 min_val, T3 max_val)
{
return 0;
}
pure clamp12266b(T1, T2, T3)(T1 x, T2 min_val, T3 max_val)
{
return 0;
}
@disable pure clamp12266c(T1, T2, T3)(T1 x, T2 min_val, T3 max_val)
{
return 0;
}
alias Dg13832 = ref int delegate();
class TestClass
{
int aa;
int b1;
int b2;
this(int b1, int b2)
{
this.b1 = b1;
this.b2 = b2;
}
ref foo()
{
return aa;
}
ref retFunc() return
{
return aa;
}
@nogc @trusted @disable ~this()
{
}
}
class FooA
{
protected void method42()
{
}
@safe ~this()
{
}
}
class Bar : FooA
{
override void method42()
{
}
}
@trusted double foo()
{
int a = 5;
return a;
}
struct Foo1(size_t Size = 42 / magic())
{
}
size_t magic()
{
return 42;
}
class Foo2A
{
immutable(FooA) Dummy = new immutable(FooA);
private immutable pure nothrow @nogc @safe this()
{
}
}
struct Foo3A(T)
{
@disable this(this);
@disable this();
}
ref @safe int foo(return ref int a)
{
return a;
}
@safe int* foo(return scope int* a)
{
return a;
}
ref @safe int* foo(return ref scope int* a)
{
return a;
}
struct SafeS
{
@safe
{
ref SafeS foo() return
{
return this;
}
scope SafeS foo2() return
{
return this;
}
ref scope SafeS foo3() return
{
static SafeS s;
return s;
}
int* p;
}
}
void test13x(@(10) int a, @(20) int, @(tuple(30), tuple(40)) int[] arr...)
{
}
enum Test14UDA1;
struct Test14UDA2
{
string str;
}
Test14UDA2 test14uda3(string name)
{
return Test14UDA2(name);
}
struct Test14UDA4(string v)
{
}
void test14x(@(Test14UDA1) int, @Test14UDA2("1") int, @test14uda3("2") int, @(Test14UDA4!"3") int)
{
}
void test15x(@(20) void delegate(int) @safe dg)
{
}
T throwStuff(T)(T t)
{
if (false)
test13x(1, throw new Exception(""), 2);
return t ? t : throw new Exception("Bad stuff happens!");
}
class C12344
{
abstract int c12344(int x)
in (x > 0)
out(result)
{
assert(result > 0);
}
;
}
interface I12344
{
int i12344(int x)
in (x > 0)
out(result)
{
assert(result > 0);
}
;
}
|
D
|
module android.java.android.webkit.WebSettings;
public import android.java.android.webkit.WebSettings_d_interface;
import arsd.jni : ImportExportImpl;
mixin ImportExportImpl!WebSettings;
import import6 = android.java.java.lang.Class;
|
D
|
module UnrealScript.TribesGame.TrProj_Tracer;
import ScriptClasses;
import UnrealScript.Helpers;
import UnrealScript.Engine.Actor;
import UnrealScript.TribesGame.TrProjectile;
extern(C++) interface TrProj_Tracer : TrProjectile
{
public extern(D):
private static __gshared ScriptClass mStaticClass;
@property final static ScriptClass StaticClass() { mixin(MGSCC("Class TribesGame.TrProj_Tracer")); }
private static __gshared TrProj_Tracer mDefaultProperties;
@property final static TrProj_Tracer DefaultProperties() { mixin(MGDPC("TrProj_Tracer", "TrProj_Tracer TribesGame.Default__TrProj_Tracer")); }
static struct Functions
{
private static __gshared
{
ScriptFunction mPostBeginPlay;
ScriptFunction mReplicatedEvent;
ScriptFunction mCalcTracerAccel;
ScriptFunction mInitTracer;
ScriptFunction mKillProjectile;
ScriptFunction mScaleDownFinishedNotify;
ScriptFunction mScaleUpFinishedNotify;
ScriptFunction mOutsideWorldBounds;
ScriptFunction mTick;
ScriptFunction mExplode;
ScriptFunction mRecycle;
ScriptFunction mReset;
ScriptFunction mWakeProjectile;
ScriptFunction mProcessTouch;
}
public @property static final
{
ScriptFunction PostBeginPlay() { mixin(MGF("mPostBeginPlay", "Function TribesGame.TrProj_Tracer.PostBeginPlay")); }
ScriptFunction ReplicatedEvent() { mixin(MGF("mReplicatedEvent", "Function TribesGame.TrProj_Tracer.ReplicatedEvent")); }
ScriptFunction CalcTracerAccel() { mixin(MGF("mCalcTracerAccel", "Function TribesGame.TrProj_Tracer.CalcTracerAccel")); }
ScriptFunction InitTracer() { mixin(MGF("mInitTracer", "Function TribesGame.TrProj_Tracer.InitTracer")); }
ScriptFunction KillProjectile() { mixin(MGF("mKillProjectile", "Function TribesGame.TrProj_Tracer.KillProjectile")); }
ScriptFunction ScaleDownFinishedNotify() { mixin(MGF("mScaleDownFinishedNotify", "Function TribesGame.TrProj_Tracer.ScaleDownFinishedNotify")); }
ScriptFunction ScaleUpFinishedNotify() { mixin(MGF("mScaleUpFinishedNotify", "Function TribesGame.TrProj_Tracer.ScaleUpFinishedNotify")); }
ScriptFunction OutsideWorldBounds() { mixin(MGF("mOutsideWorldBounds", "Function TribesGame.TrProj_Tracer.OutsideWorldBounds")); }
ScriptFunction Tick() { mixin(MGF("mTick", "Function TribesGame.TrProj_Tracer.Tick")); }
ScriptFunction Explode() { mixin(MGF("mExplode", "Function TribesGame.TrProj_Tracer.Explode")); }
ScriptFunction Recycle() { mixin(MGF("mRecycle", "Function TribesGame.TrProj_Tracer.Recycle")); }
ScriptFunction Reset() { mixin(MGF("mReset", "Function TribesGame.TrProj_Tracer.Reset")); }
ScriptFunction WakeProjectile() { mixin(MGF("mWakeProjectile", "Function TribesGame.TrProj_Tracer.WakeProjectile")); }
ScriptFunction ProcessTouch() { mixin(MGF("mProcessTouch", "Function TribesGame.TrProj_Tracer.ProcessTouch")); }
}
}
@property final
{
auto ref
{
Vector m_vTracerDrawScale3D() { mixin(MGPC("Vector", 824)); }
Vector m_vInitialFrameOfRefVelocity() { mixin(MGPC("Vector", 864)); }
Vector m_vDestinationLoc() { mixin(MGPC("Vector", 852)); }
float m_fMeshScaleDownTime() { mixin(MGPC("float", 848)); }
float m_fCurScale() { mixin(MGPC("float", 844)); }
float m_fMeshScaleUpTime() { mixin(MGPC("float", 836)); }
float m_fAccelRate() { mixin(MGPC("float", 820)); }
// ERROR: Unsupported object class 'ComponentProperty' for the property named 'm_TracerPSC'!
}
bool m_bScalingDown() { mixin(MGBPC(840, 0x2)); }
bool m_bScalingDown(bool val) { mixin(MSBPC(840, 0x2)); }
bool m_bScaledUp() { mixin(MGBPC(840, 0x1)); }
bool m_bScaledUp(bool val) { mixin(MSBPC(840, 0x1)); }
}
final:
void PostBeginPlay()
{
(cast(ScriptObject)this).ProcessEvent(Functions.PostBeginPlay, cast(void*)0, cast(void*)0);
}
void ReplicatedEvent(ScriptName VarName)
{
ubyte params[8];
params[] = 0;
*cast(ScriptName*)params.ptr = VarName;
(cast(ScriptObject)this).ProcessEvent(Functions.ReplicatedEvent, params.ptr, cast(void*)0);
}
void CalcTracerAccel()
{
(cast(ScriptObject)this).ProcessEvent(Functions.CalcTracerAccel, cast(void*)0, cast(void*)0);
}
void InitTracer(Vector Start, Vector End)
{
ubyte params[24];
params[] = 0;
*cast(Vector*)params.ptr = Start;
*cast(Vector*)¶ms[12] = End;
(cast(ScriptObject)this).ProcessEvent(Functions.InitTracer, params.ptr, cast(void*)0);
}
void KillProjectile()
{
(cast(ScriptObject)this).ProcessEvent(Functions.KillProjectile, cast(void*)0, cast(void*)0);
}
void ScaleDownFinishedNotify()
{
(cast(ScriptObject)this).ProcessEvent(Functions.ScaleDownFinishedNotify, cast(void*)0, cast(void*)0);
}
void ScaleUpFinishedNotify()
{
(cast(ScriptObject)this).ProcessEvent(Functions.ScaleUpFinishedNotify, cast(void*)0, cast(void*)0);
}
void OutsideWorldBounds()
{
(cast(ScriptObject)this).ProcessEvent(Functions.OutsideWorldBounds, cast(void*)0, cast(void*)0);
}
void Tick(float DeltaTime)
{
ubyte params[4];
params[] = 0;
*cast(float*)params.ptr = DeltaTime;
(cast(ScriptObject)this).ProcessEvent(Functions.Tick, params.ptr, cast(void*)0);
}
void Explode(Vector HitLocation, Vector HitNormal)
{
ubyte params[24];
params[] = 0;
*cast(Vector*)params.ptr = HitLocation;
*cast(Vector*)¶ms[12] = HitNormal;
(cast(ScriptObject)this).ProcessEvent(Functions.Explode, params.ptr, cast(void*)0);
}
void Recycle()
{
(cast(ScriptObject)this).ProcessEvent(Functions.Recycle, cast(void*)0, cast(void*)0);
}
void Reset()
{
(cast(ScriptObject)this).ProcessEvent(Functions.Reset, cast(void*)0, cast(void*)0);
}
void WakeProjectile()
{
(cast(ScriptObject)this).ProcessEvent(Functions.WakeProjectile, cast(void*)0, cast(void*)0);
}
void ProcessTouch(Actor Other, Vector HitLocation, Vector HitNormal)
{
ubyte params[28];
params[] = 0;
*cast(Actor*)params.ptr = Other;
*cast(Vector*)¶ms[4] = HitLocation;
*cast(Vector*)¶ms[16] = HitNormal;
(cast(ScriptObject)this).ProcessEvent(Functions.ProcessTouch, params.ptr, cast(void*)0);
}
}
|
D
|
import std.stdio;
import std.file;
import std.path;
import std.array;
import std.string;
import std.conv;
import std.parallelism;
import std.concurrency;
import std.process;
import std.uuid;
import std.regex;
int main(string[] args) {
//
// Startup message
//
writeln("PDFSearch v1.0.0");
//
// Looking for the right arguments:
//
if(args.length < 4) {
writeln("Expect three arguments:");
writeln("(1) a directory where to store the index");
writeln("(2) a base directory where to start with the search");
writeln("(3) a command out of this list: 'search', 'index', 'maintain'");
return 1;
}
auto dataDirectory = args[1].asNormalizedPath().array;
auto pdfDirectory = args[2].asNormalizedPath().array;
auto command = args[3].toLower();
//
// Check the external tool dependency:
//
if(!isAvailableAtPath("pdftotext")) {
writeln("Please install 'pdftotext' and make it available trough your path.");
return 2;
}
//
// Check that both directories are available:
//
if(!pdfDirectory.exists() || !pdfDirectory.isDir()) {
writefln("The given PDF directory ('%s') is not available.", pdfDirectory);
return 3;
}
if(!dataDirectory.exists()) {
writefln("The given data directory ('%s') is not available. Thus, it gets created now.", dataDirectory);
dataDirectory.mkdirRecurse();
} else {
if(!dataDirectory.isDir()) {
writefln("The given data directory ('%s') is not a directory.", dataDirectory);
return 4;
}
}
//
// Check and perhaps set up the environment:
//
auto lookupFilename = asNormalizedPath(dataDirectory ~ dirSeparator ~ "lookup").array;
auto indexDirectory = asNormalizedPath(dataDirectory ~ dirSeparator ~ "data").array;
if(!indexDirectory.exists()) {
writeln("Create the directory for indexes now.");
indexDirectory.mkdirRecurse();
}
if(!lookupFilename.exists()) {
writeln("Create the lookup table now.");
std.file.write(lookupFilename, "");
}
//
// Switch regarding the command
//
writefln("The given command is: '%s'", command);
if(command == "index") {
index(to!string(pdfDirectory), to!string(lookupFilename), to!string(indexDirectory));
return 0;
}
if(command == "search") {
if(args.length != 8) {
writeln("For the search command, additional four arguments are needed:");
writeln("(4) a list of necessary keywords");
writeln("(5) a list of forbidden keywords");
writeln("(6) a list of proximity keywords");
writeln("(7) a maximal distance for the proximity keywords");
writeln();
writeln("The necessary keywords must be appear inside the PDF, while the forbidden");
writeln("keywords cannot appear. All proximity keywords must appear at the given");
writeln("maximal distance of words. Arguments can be empty.");
writeln();
writeln("Example:");
writeln(`PDFSearch ~/.pdf ~ search "internet,issue" "" "internet,of,things" 3`);
return 6;
}
search(to!string(lookupFilename), to!string(indexDirectory), to!string(pdfDirectory), args[4], args[5], args[6], args[7]);
return 0;
}
if(command == "maintain") {
maintain(to!string(lookupFilename), to!string(indexDirectory));
index(to!string(pdfDirectory), to!string(lookupFilename), to!string(indexDirectory));
return 0;
}
writefln("The command '%s' is unknown. Known commands are: 'search', 'index', 'maintain'.", command);
return 5;
}
// Indexing of PDF files
void index(string pdfDirectory, string lookupFilename, string dataDirectory) {
scope(exit) {
writeln("Indexing done.");
}
writeln("Indexing start.");
writeln("Create a list of all PDF files.");
auto files = dirEntries(pdfDirectory, "*.pdf", SpanMode.breadth).array;
writefln("Found %d PDF files.", files.length);
// Read the last known lookup state:
auto currentLookup = readText(lookupFilename);
// Build the new lookup table, based on the last state:
shared(string) lookupString = currentLookup;
// Define a plotter, who draws the progress bar:
auto plotterTid = spawn(function void(size_t maxN, Tid owner) {
auto maxWidth = 25; // Max count of characters
auto currentWidth = 0;
auto currentN = 0;
auto factor4Width = to!double(maxWidth) / 100.0;
writeln();
writeln("|0% 100%|");
writeln("+-------------------------+");
std.stdio.write("|");
stdout.flush();
while(true) {
auto received = receiveOnly!int();
if(received == -1) {
currentN = to!int(maxN);
} else {
currentN = received;
}
// Calculate the current percentage:
auto currentPercentage = (to!double(currentN) / to!double(maxN)) * 100.0;
// Calculate the current width:
auto newWidth = to!int(currentPercentage * factor4Width);
// No change?
if(newWidth == currentWidth) {
continue;
}
// There was a change. Draw the change:
std.stdio.write("=".replicate(newWidth - currentWidth));
stdout.flush();
// Canceled?
if(received == -1) {
break;
}
// Store this state:
currentWidth = newWidth;
}
// Append the ending:
writeln("|");
writeln();
// Signal back, that this thread is done:
owner.send("ACK");
}, files.length, thisTid());
setMaxMailboxSize(plotterTid, 10000, OnCrowding.ignore);
// Define a receiver for all messages of the parallel execution of PDF files:
auto receiverTid = spawn(function void(size_t count, shared(string) *lookup, Tid plotter, Tid owner) {
// We know how many messages arrive:
foreach(number; 0 .. count) {
auto received = receiveOnly!string();
if(received == "DONE") {
break;
}
// Show the progress:
plotter.send(to!int(number));
if(received == "NEXT") {
continue;
}
*lookup = *lookup ~ received ~ "\n";
}
owner.send("ACK");
}, files.length, &lookupString, plotterTid, thisTid());
setMaxMailboxSize(receiverTid, 10000, OnCrowding.block);
// Parallel execution of PDF files:
foreach(n, filename; parallel(files)) {
// Only process new files:
if(currentLookup.indexOf(filename) == -1) {
// File is not known yet:
auto dataId = randomUUID().toString();
auto pid = spawnProcess(["pdftotext", "-q", filename, dataDirectory ~ dirSeparator ~ dataId ~ ".txt"]);
receiverTid.send(dataId ~ ';' ~ filename);
wait(pid);
} else {
// File is known:
receiverTid.send("NEXT");
}
}
// Terminate the receivers (in case that not all files were new):
receiverTid.send("DONE");
plotterTid.send(-1);
receiveOnly!string();
receiveOnly!string();
//
// Note: This point gets reached after all PDF files are processed. The foreach gets blocked until all threads are finished.
//
// Write the new lookup table:
std.file.write(lookupFilename, lookupString);
}
// Searching for PDF files
void search(string lookupFilename, string dataDirectory, string pdfDirectory, string andKeywords, string notKeywords, string proximityKeywords, string proximityMaxDistanz) {
scope(exit) {
writeln("Searching done.");
}
// Load the lookup table:
auto lookupTable = readText(lookupFilename).splitLines();
// Reserve space for the maximum of possible matches:
shared(string[]) matches; matches.length = lookupTable.length;
// Define a matches listener where the results are collected:
auto matchesTid = spawn(function void(Tid owner, shared(string[]) results, shared(string) baseDirectory) {
writeln();
writeln("Please enter the desired number in order to open the file or END to exit.");
writeln("Matches:");
size_t counter = -1;
while(true) {
auto received = receiveOnly!string();
if(received == "DONE") {
break;
}
if(received == "READY") {
writeln("Searching done. Please enter a number to open the file or END to exit.");
continue;
}
counter++;
writefln("[%5d] %s", counter, received.replace(baseDirectory, ""));
results[counter] = received;
}
owner.send("ACK");
}, thisTid(), matches, cast(shared) pdfDirectory);
setMaxMailboxSize(matchesTid, 10000, OnCrowding.block);
// Listener for user's input:
auto userTid = spawn(function void(Tid owner, shared(string[]) results, Tid matchesTid) {
while(true) {
auto input = readln().strip().toLower();
if(input == "end") {
matchesTid.send("DONE");
break;
}
spawnProcess(["open", "file://" ~ results[to!int(input)]]);
}
owner.send("ACK");
}, thisTid(), matches, matchesTid);
// Process in parallel all indexes:
auto files = dirEntries(dataDirectory, "*.txt", SpanMode.breadth).array;
foreach(n, filename; parallel(files)) {
auto cancel = false;
// Extract the filename without extension:
auto uuid = filename.baseName(".txt");
// Read the entire content:
auto content = readText(filename).toLower();
// Get the individual keywords:
auto andKeywordsElements = andKeywords.toLower().split(",");
auto notKeywordsElements = notKeywords.toLower().split(",");
auto proximityKeywordsElements = proximityKeywords.toLower().replace(",", "|");
// Append the proximity words also to the AND list to ensure, that each word appears in the PDF.
andKeywordsElements ~= proximityKeywords.toLower().split(",");
// Check the AND keywords:
foreach(andKeyword; andKeywordsElements) {
if(content.indexOf(andKeyword) == -1) {
// Keyword is not present:
cancel = true;
break;
}
}
if(!cancel) {
// Check the NOT keywords:
foreach(notKeyword; notKeywordsElements) {
if(content.indexOf(notKeyword) > -1) {
// Keyword is present:
cancel = true;
break;
}
}
if(!cancel) {
// Proximity search
auto proximityMatch = false;
if(proximityKeywordsElements.length > 0) {
auto rex = regex(`\b(` ~ proximityKeywordsElements ~ `)(?:\W+\w+){1,` ~ proximityMaxDistanz ~ `}?\W+(` ~ proximityKeywordsElements ~ `)\b`);
proximityMatch = !matchFirst(content, rex).empty;
}
if(proximityMatch || proximityKeywordsElements.length == 0) {
// This file is a match! Find the PDF file name:
foreach(line; lookupTable) {
if(line.indexOf(uuid) == -1) {
continue;
}
auto cleanLine = line.strip();
auto elements = cleanLine.split(";");
auto dataFile = elements[0];
auto pdfFilename = elements[1];
matchesTid.send(pdfFilename);
break;
}
}
}
}
}
// Search is done:
matchesTid.send("READY");
// Wait for the listeners:
receiveOnly!string();
receiveOnly!string();
}
// Maintain the data e.g. delete dead entries, etc.
void maintain(string lookupFilename, string dataDirectory) {
scope(exit) {
writeln("Maintenance done.");
}
writeln("Maintenance start.");
//
// 1. Phase
//
writeln("Phase 1: Checking lookup table.");
shared(string) newLookup = "";
// Define a receiver for healthy entries:
auto healthyReceiverTid = spawn(function void(shared(string) *lookup, Tid owner) {
while(true) {
auto received = receiveOnly!string();
if(received == "DONE") {
break;
}
*lookup = *lookup ~ received ~ "\n";
}
owner.send("ACK");
}, &newLookup, thisTid());
setMaxMailboxSize(healthyReceiverTid, 10000, OnCrowding.block);
// Read the entire table by lines:
auto lookupTable = readText(lookupFilename).splitLines();
foreach(n, line; parallel(lookupTable)) {
auto cleanLine = line.strip();
auto elements = cleanLine.split(";");
auto dataFile = elements[0];
auto pdfFilename = elements[1];
// Is the file existing?
if(pdfFilename.exists()) {
healthyReceiverTid.send(cleanLine);
}
}
// End signal for the receiver:
healthyReceiverTid.send("DONE");
receiveOnly!string(); // Wait for receiver to finish.
// Write the maintained lookup table:
std.file.write(lookupFilename, newLookup);
//
// 2. Phase
//
writeln("Phase 2: Checking indexes.");
writeln("Read all file names.");
auto files = dirEntries(dataDirectory, "*.txt", SpanMode.breadth).array;
foreach(n, filename; parallel(files)) {
// Extract the filename without extension:
auto uuid = filename.baseName(".txt");
// Check if this id is used inside the lookup:
if(newLookup.indexOf(uuid) == -1) {
// This index is a dead entry: Delete this index.
remove(filename);
}
}
}
// Source: https://p0nce.github.io/d-idioms/#Is-a-specific-program-available-in-PATH?
bool isAvailableAtPath(string executableName)
{
import std.process: environment;
import std.path: pathSeparator, buildPath;
import std.file: exists;
import std.algorithm: splitter;
// pathSeparator: Windows uses ";" separator, POSIX uses ":"
foreach (dir; splitter(environment["PATH"], pathSeparator))
{
auto path = buildPath(dir, executableName);
if (exists(path))
return true;
}
return false;
}
|
D
|
// This source code is in the public domain.
// Dialog: Help - About
import std.stdio;
import gtk.MainWindow;
import gtk.Box;
import gtk.Main;
import gtk.Menu;
import gtk.MenuBar;
import gtk.MenuItem;
import gtk.Widget;
import gdk.Event;
import gtk.AboutDialog;
import gdk.Pixbuf;
import gtk.Window;
void main(string[] args)
{
TestRigWindow testRigWindow;
Main.init(args);
testRigWindow = new TestRigWindow();
Main.run();
} // main()
class TestRigWindow : MainWindow
{
string title = "Dialog: Help - About";
this()
{
super(title);
setDefaultSize(640, 480);
addOnDestroy(&quitApp);
AppBox appBox = new AppBox(this);
add(appBox);
showAll();
} // this()
void quitApp(Widget w)
{
// do other exit stuff here if necessary
Main.quit();
} // quitApp()
} // testRigWindow
class AppBox : Box
{
int padding = 10;
MyMenuBar menuBar;
this(Window parentWindow)
{
super(Orientation.VERTICAL, padding);
menuBar = new MyMenuBar(parentWindow);
packStart(menuBar, false, false, 0);
} // this()
} // class AppBox
class MyMenuBar : MenuBar
{
string helpHeaderLabel = "Help";
HelpHeader helpHeader;
this(Window parentWindow)
{
super();
helpHeader = new HelpHeader(helpHeaderLabel, parentWindow);
append(helpHeader);
} // this()
} // class MyMenuBar
class HelpHeader : MenuItem
{
HelpMenu helpMenu;
// arg: a Menu object
this(string headerTitle, Window parentWindow)
{
super(headerTitle);
helpMenu = new HelpMenu(parentWindow);
setSubmenu(helpMenu);
} // this()
} // class HelpHeader
class HelpMenu : Menu
{
AboutMenuItem aboutMenuItem;
// arg: an array of items
this(Window parentWindow)
{
super();
aboutMenuItem = new AboutMenuItem(parentWindow);
append(aboutMenuItem);
} // this()
} // class HelpMenu
class AboutMenuItem : MenuItem
{
string itemLabel = "About";
string sectionName = "Them What Done Stuff";
string[] people = ["Laurence Find", "Jerome Hayward", "Dick van Puddlesopper"];
string[] artists = ["Alice Warhol", "Salvador Deli", "My Brother-in-law, Bill"];
string comments = "This is a fine bit of software built for the rigors of testing dialog windows.";
string[] documenters = ["Billy Buck Thorndyke", "Phil Gates"];
string license = "This is a FOSS Budget build of a GNOLD project";
License licenseType = License.ARTISTIC;
string programName = "About Dialog Demo";
string protection = "Copywrong 2019 © The Three Stool Pigeons";
Pixbuf logoPixbuf;
string pixbufFilename = "images/logo.png";
string productVersion = "0.10 (the first, not the tenth, for crying out loud)";
string website = "http://gtkdcoding.com";
string websiteLabel = "gtkDcoding";
Window parentWindow;
AboutDialog aboutDialog;
this(Window extParentWindow)
{
super(itemLabel);
addOnActivate(&doSomething);
parentWindow = extParentWindow;
} // this()
void doSomething(MenuItem mi)
{
int responseID;
writeln("Bringing up dialog...");
logoPixbuf = new Pixbuf(pixbufFilename);
// Although it seems we should do all this config stuff in this()
// it has to be done here.
AboutDialog aboutDialog = new AboutDialog();
aboutDialog.setArtists(artists);
aboutDialog.setAuthors(people);
aboutDialog.setComments(comments);
aboutDialog.setCopyright(protection);
aboutDialog.setDocumenters(documenters);
aboutDialog.setLicense(license);
aboutDialog.setLicenseType(licenseType);
aboutDialog.addCreditSection(sectionName, people); // shows when the Credits button is clicked
aboutDialog.setProgramName(programName);
aboutDialog.setLogo(logoPixbuf);
aboutDialog.setVersion(productVersion);
aboutDialog.setWebsite(website);
aboutDialog.setWebsiteLabel(websiteLabel);
aboutDialog.setTransientFor(parentWindow);
aboutDialog.run();
aboutDialog.destroy();
} // doSomething()
} // class AboutMenuItem
|
D
|
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 3.0.0
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
module vtkGenericDataObjectReader;
static import vtkd_im;
static import core.stdc.config;
static import std.conv;
static import std.string;
static import std.conv;
static import std.string;
static import vtkObjectBase;
static import vtkDataObject;
static import vtkGraph;
static import vtkPolyData;
static import vtkRectilinearGrid;
static import vtkStructuredGrid;
static import vtkStructuredPoints;
static import vtkTable;
static import vtkTree;
static import vtkUnstructuredGrid;
static import vtkDataReader;
class vtkGenericDataObjectReader : vtkDataReader.vtkDataReader {
private void* swigCPtr;
public this(void* cObject, bool ownCObject) {
super(vtkd_im.vtkGenericDataObjectReader_Upcast(cObject), ownCObject);
swigCPtr = cObject;
}
public static void* swigGetCPtr(vtkGenericDataObjectReader obj) {
return (obj is null) ? null : obj.swigCPtr;
}
mixin vtkd_im.SwigOperatorDefinitions;
~this() {
dispose();
}
public override void dispose() {
synchronized(this) {
if (swigCPtr !is null) {
if (swigCMemOwn) {
swigCMemOwn = false;
vtkd_im.delete_vtkGenericDataObjectReader(cast(void*)swigCPtr);
}
swigCPtr = null;
super.dispose();
}
}
}
public static vtkGenericDataObjectReader New() {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_New();
vtkGenericDataObjectReader ret = (cPtr is null) ? null : new vtkGenericDataObjectReader(cPtr, false);
return ret;
}
public static int IsTypeOf(string type) {
auto ret = vtkd_im.vtkGenericDataObjectReader_IsTypeOf((type ? std.string.toStringz(type) : null));
return ret;
}
public static vtkGenericDataObjectReader SafeDownCast(vtkObjectBase.vtkObjectBase o) {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_SafeDownCast(vtkObjectBase.vtkObjectBase.swigGetCPtr(o));
vtkGenericDataObjectReader ret = (cPtr is null) ? null : new vtkGenericDataObjectReader(cPtr, false);
return ret;
}
public vtkGenericDataObjectReader NewInstance() const {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_NewInstance(cast(void*)swigCPtr);
vtkGenericDataObjectReader ret = (cPtr is null) ? null : new vtkGenericDataObjectReader(cPtr, false);
return ret;
}
alias vtkDataReader.vtkDataReader.NewInstance NewInstance;
public vtkDataObject.vtkDataObject GetOutput() {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_GetOutput__SWIG_0(cast(void*)swigCPtr);
vtkDataObject.vtkDataObject ret = (cPtr is null) ? null : new vtkDataObject.vtkDataObject(cPtr, false);
return ret;
}
public vtkDataObject.vtkDataObject GetOutput(int idx) {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_GetOutput__SWIG_1(cast(void*)swigCPtr, idx);
vtkDataObject.vtkDataObject ret = (cPtr is null) ? null : new vtkDataObject.vtkDataObject(cPtr, false);
return ret;
}
public vtkGraph.vtkGraph GetGraphOutput() {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_GetGraphOutput(cast(void*)swigCPtr);
vtkGraph.vtkGraph ret = (cPtr is null) ? null : new vtkGraph.vtkGraph(cPtr, false);
return ret;
}
public vtkPolyData.vtkPolyData GetPolyDataOutput() {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_GetPolyDataOutput(cast(void*)swigCPtr);
vtkPolyData.vtkPolyData ret = (cPtr is null) ? null : new vtkPolyData.vtkPolyData(cPtr, false);
return ret;
}
public vtkRectilinearGrid.vtkRectilinearGrid GetRectilinearGridOutput() {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_GetRectilinearGridOutput(cast(void*)swigCPtr);
vtkRectilinearGrid.vtkRectilinearGrid ret = (cPtr is null) ? null : new vtkRectilinearGrid.vtkRectilinearGrid(cPtr, false);
return ret;
}
public vtkStructuredGrid.vtkStructuredGrid GetStructuredGridOutput() {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_GetStructuredGridOutput(cast(void*)swigCPtr);
vtkStructuredGrid.vtkStructuredGrid ret = (cPtr is null) ? null : new vtkStructuredGrid.vtkStructuredGrid(cPtr, false);
return ret;
}
public vtkStructuredPoints.vtkStructuredPoints GetStructuredPointsOutput() {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_GetStructuredPointsOutput(cast(void*)swigCPtr);
vtkStructuredPoints.vtkStructuredPoints ret = (cPtr is null) ? null : new vtkStructuredPoints.vtkStructuredPoints(cPtr, false);
return ret;
}
public vtkTable.vtkTable GetTableOutput() {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_GetTableOutput(cast(void*)swigCPtr);
vtkTable.vtkTable ret = (cPtr is null) ? null : new vtkTable.vtkTable(cPtr, false);
return ret;
}
public vtkTree.vtkTree GetTreeOutput() {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_GetTreeOutput(cast(void*)swigCPtr);
vtkTree.vtkTree ret = (cPtr is null) ? null : new vtkTree.vtkTree(cPtr, false);
return ret;
}
public vtkUnstructuredGrid.vtkUnstructuredGrid GetUnstructuredGridOutput() {
void* cPtr = vtkd_im.vtkGenericDataObjectReader_GetUnstructuredGridOutput(cast(void*)swigCPtr);
vtkUnstructuredGrid.vtkUnstructuredGrid ret = (cPtr is null) ? null : new vtkUnstructuredGrid.vtkUnstructuredGrid(cPtr, false);
return ret;
}
public int ReadOutputType() {
auto ret = vtkd_im.vtkGenericDataObjectReader_ReadOutputType(cast(void*)swigCPtr);
return ret;
}
public this() {
this(vtkd_im.new_vtkGenericDataObjectReader(), true);
}
}
|
D
|
// Written in the D programming language.
/**
This module defines the notion of a range. Ranges generalize the concept of
arrays, lists, or anything that involves sequential access. This abstraction
enables the same set of algorithms (see $(MREF std, algorithm)) to be used
with a vast variety of different concrete types. For example,
a linear search algorithm such as $(REF find, std, algorithm, searching)
works not just for arrays, but for linked-lists, input files,
incoming network data, etc.
Guides:
There are many articles available that can bolster understanding ranges:
$(UL
$(LI Ali Çehreli's $(HTTP ddili.org/ders/d.en/ranges.html, tutorial on ranges)
for the basics of working with and creating range-based code.)
$(LI Jonathan M. Davis $(LINK2 http://dconf.org/2015/talks/davis.html, $(I Introduction to Ranges))
talk at DConf 2015 a vivid introduction from its core constructs to practical advice.)
$(LI The DLang Tour's $(LINK2 http://tour.dlang.org/tour/en/basics/ranges, chapter on ranges)
for an interactive introduction.)
$(LI H. S. Teoh's $(LINK2 http://wiki.dlang.org/Component_programming_with_ranges, tutorial on
component programming with ranges) for a real-world showcase of the influence
of range-based programming on complex algorithms.)
$(LI Andrei Alexandrescu's article
$(LINK2 http://www.informit.com/articles/printerfriendly.aspx?p=1407357$(AMP)rll=1,
$(I On Iteration)) for conceptual aspect of ranges and the motivation
)
)
Submodules:
This module has two submodules:
The $(MREF std, range, primitives) submodule
provides basic range functionality. It defines several templates for testing
whether a given object is a range, what kind of range it is, and provides
some common range operations.
The $(MREF std, range, interfaces) submodule
provides object-based interfaces for working with ranges via runtime
polymorphism.
The remainder of this module provides a rich set of range creation and
composition templates that let you construct new ranges out of existing ranges:
$(SCRIPT inhibitQuickIndex = 1;)
$(BOOKTABLE ,
$(TR $(TD $(LREF chain))
$(TD Concatenates several ranges into a single range.
))
$(TR $(TD $(LREF choose))
$(TD Chooses one of two ranges at runtime based on a boolean condition.
))
$(TR $(TD $(LREF chooseAmong))
$(TD Chooses one of several ranges at runtime based on an index.
))
$(TR $(TD $(LREF chunks))
$(TD Creates a range that returns fixed-size chunks of the original
range.
))
$(TR $(TD $(LREF cycle))
$(TD Creates an infinite range that repeats the given forward range
indefinitely. Good for implementing circular buffers.
))
$(TR $(TD $(LREF drop))
$(TD Creates the range that results from discarding the first $(I n)
elements from the given range.
))
$(TR $(TD $(LREF dropBack))
$(TD Creates the range that results from discarding the last $(I n)
elements from the given range.
))
$(TR $(TD $(LREF dropExactly))
$(TD Creates the range that results from discarding exactly $(I n)
of the first elements from the given range.
))
$(TR $(TD $(LREF dropBackExactly))
$(TD Creates the range that results from discarding exactly $(I n)
of the last elements from the given range.
))
$(TR $(TD $(LREF dropOne))
$(TD Creates the range that results from discarding
the first element from the given range.
))
$(TR $(TD $(D $(LREF dropBackOne)))
$(TD Creates the range that results from discarding
the last element from the given range.
))
$(TR $(TD $(LREF enumerate))
$(TD Iterates a range with an attached index variable.
))
$(TR $(TD $(LREF evenChunks))
$(TD Creates a range that returns a number of chunks of
approximately equal length from the original range.
))
$(TR $(TD $(LREF frontTransversal))
$(TD Creates a range that iterates over the first elements of the
given ranges.
))
$(TR $(TD $(LREF generate))
$(TD Creates a range by successive calls to a given function. This
allows to create ranges as a single delegate.
))
$(TR $(TD $(LREF indexed))
$(TD Creates a range that offers a view of a given range as though
its elements were reordered according to a given range of indices.
))
$(TR $(TD $(LREF iota))
$(TD Creates a range consisting of numbers between a starting point
and ending point, spaced apart by a given interval.
))
$(TR $(TD $(LREF lockstep))
$(TD Iterates $(I n) ranges in lockstep, for use in a `foreach`
loop. Similar to `zip`, except that `lockstep` is designed
especially for `foreach` loops.
))
$(TR $(TD $(LREF nullSink))
$(TD An output range that discards the data it receives.
))
$(TR $(TD $(LREF only))
$(TD Creates a range that iterates over the given arguments.
))
$(TR $(TD $(LREF padLeft))
$(TD Pads a range to a specified length by adding a given element to
the front of the range. Is lazy if the range has a known length.
))
$(TR $(TD $(LREF padRight))
$(TD Lazily pads a range to a specified length by adding a given element to
the back of the range.
))
$(TR $(TD $(LREF radial))
$(TD Given a random-access range and a starting point, creates a
range that alternately returns the next left and next right element to
the starting point.
))
$(TR $(TD $(LREF recurrence))
$(TD Creates a forward range whose values are defined by a
mathematical recurrence relation.
))
$(TR $(TD $(LREF refRange))
$(TD Pass a range by reference. Both the original range and the RefRange
will always have the exact same elements.
Any operation done on one will affect the other.
))
$(TR $(TD $(LREF repeat))
$(TD Creates a range that consists of a single element repeated $(I n)
times, or an infinite range repeating that element indefinitely.
))
$(TR $(TD $(LREF retro))
$(TD Iterates a bidirectional range backwards.
))
$(TR $(TD $(LREF roundRobin))
$(TD Given $(I n) ranges, creates a new range that return the $(I n)
first elements of each range, in turn, then the second element of each
range, and so on, in a round-robin fashion.
))
$(TR $(TD $(LREF sequence))
$(TD Similar to `recurrence`, except that a random-access range is
created.
))
$(TR $(TD $(D $(LREF slide)))
$(TD Creates a range that returns a fixed-size sliding window
over the original range. Unlike chunks,
it advances a configurable number of items at a time,
not one chunk at a time.
))
$(TR $(TD $(LREF stride))
$(TD Iterates a range with stride $(I n).
))
$(TR $(TD $(LREF tail))
$(TD Return a range advanced to within `n` elements of the end of
the given range.
))
$(TR $(TD $(LREF take))
$(TD Creates a sub-range consisting of only up to the first $(I n)
elements of the given range.
))
$(TR $(TD $(LREF takeExactly))
$(TD Like `take`, but assumes the given range actually has $(I n)
elements, and therefore also defines the `length` property.
))
$(TR $(TD $(LREF takeNone))
$(TD Creates a random-access range consisting of zero elements of the
given range.
))
$(TR $(TD $(LREF takeOne))
$(TD Creates a random-access range consisting of exactly the first
element of the given range.
))
$(TR $(TD $(LREF tee))
$(TD Creates a range that wraps a given range, forwarding along
its elements while also calling a provided function with each element.
))
$(TR $(TD $(LREF transposed))
$(TD Transposes a range of ranges.
))
$(TR $(TD $(LREF transversal))
$(TD Creates a range that iterates over the $(I n)'th elements of the
given random-access ranges.
))
$(TR $(TD $(LREF zip))
$(TD Given $(I n) ranges, creates a range that successively returns a
tuple of all the first elements, a tuple of all the second elements,
etc.
))
)
Sortedness:
Ranges whose elements are sorted afford better efficiency with certain
operations. For this, the $(LREF assumeSorted) function can be used to
construct a $(LREF SortedRange) from a pre-sorted range. The $(REF
sort, std, algorithm, sorting) function also conveniently
returns a $(LREF SortedRange). $(LREF SortedRange) objects provide some additional
range operations that take advantage of the fact that the range is sorted.
Source: $(PHOBOSSRC std/range/package.d)
License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
Authors: $(HTTP erdani.com, Andrei Alexandrescu), David Simcha,
$(HTTP jmdavisprog.com, Jonathan M Davis), and Jack Stouffer. Credit
for some of the ideas in building this module goes to
$(HTTP fantascienza.net/leonardo/so/, Leonardo Maffi).
*/
module std.range;
public import std.array;
public import std.range.interfaces;
public import std.range.primitives;
public import std.typecons : Flag, Yes, No;
import std.internal.attributes : betterC;
import std.meta : allSatisfy, staticMap;
import std.traits : CommonType, isCallable, isFloatingPoint, isIntegral,
isPointer, isSomeFunction, isStaticArray, Unqual, isInstanceOf;
/**
Iterates a bidirectional range backwards. The original range can be
accessed by using the `source` property. Applying retro twice to
the same range yields the original range.
Params:
r = the bidirectional range to iterate backwards
Returns:
A bidirectional range with length if `r` also provides a length. Or,
if `r` is a random access range, then the return value will be random
access as well.
See_Also:
$(REF reverse, std,algorithm,mutation) for mutating the source range directly.
*/
auto retro(Range)(Range r)
if (isBidirectionalRange!(Unqual!Range))
{
// Check for retro(retro(r)) and just return r in that case
static if (is(typeof(retro(r.source)) == Range))
{
return r.source;
}
else
{
static struct Result()
{
private alias R = Unqual!Range;
// User code can get and set source, too
R source;
static if (hasLength!R)
{
size_t retroIndex(size_t n)
{
return source.length - n - 1;
}
}
public:
alias Source = R;
@property bool empty() { return source.empty; }
@property auto save()
{
return Result(source.save);
}
@property auto ref front() { return source.back; }
void popFront() { source.popBack(); }
@property auto ref back() { return source.front; }
void popBack() { source.popFront(); }
static if (is(typeof(source.moveBack())))
{
ElementType!R moveFront()
{
return source.moveBack();
}
}
static if (is(typeof(source.moveFront())))
{
ElementType!R moveBack()
{
return source.moveFront();
}
}
static if (hasAssignableElements!R)
{
@property void front(ElementType!R val)
{
source.back = val;
}
@property void back(ElementType!R val)
{
source.front = val;
}
}
static if (isRandomAccessRange!(R) && hasLength!(R))
{
auto ref opIndex(size_t n) { return source[retroIndex(n)]; }
static if (hasAssignableElements!R)
{
void opIndexAssign(ElementType!R val, size_t n)
{
source[retroIndex(n)] = val;
}
}
static if (is(typeof(source.moveAt(0))))
{
ElementType!R moveAt(size_t index)
{
return source.moveAt(retroIndex(index));
}
}
static if (hasSlicing!R)
typeof(this) opSlice(size_t a, size_t b)
{
return typeof(this)(source[source.length - b .. source.length - a]);
}
}
static if (hasLength!R)
{
@property auto length()
{
return source.length;
}
alias opDollar = length;
}
}
return Result!()(r);
}
}
///
pure @safe nothrow @nogc unittest
{
import std.algorithm.comparison : equal;
int[5] a = [ 1, 2, 3, 4, 5 ];
int[5] b = [ 5, 4, 3, 2, 1 ];
assert(equal(retro(a[]), b[]));
assert(retro(a[]).source is a[]);
assert(retro(retro(a[])) is a[]);
}
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
static assert(isBidirectionalRange!(typeof(retro("hello"))));
int[] a;
static assert(is(typeof(a) == typeof(retro(retro(a)))));
assert(retro(retro(a)) is a);
static assert(isRandomAccessRange!(typeof(retro([1, 2, 3]))));
void test(int[] input, int[] witness)
{
auto r = retro(input);
assert(r.front == witness.front);
assert(r.back == witness.back);
assert(equal(r, witness));
}
test([ 1 ], [ 1 ]);
test([ 1, 2 ], [ 2, 1 ]);
test([ 1, 2, 3 ], [ 3, 2, 1 ]);
test([ 1, 2, 3, 4 ], [ 4, 3, 2, 1 ]);
test([ 1, 2, 3, 4, 5 ], [ 5, 4, 3, 2, 1 ]);
test([ 1, 2, 3, 4, 5, 6 ], [ 6, 5, 4, 3, 2, 1 ]);
immutable foo = [1,2,3].idup;
auto r = retro(foo);
assert(equal(r, [3, 2, 1]));
}
pure @safe nothrow unittest
{
import std.internal.test.dummyrange : AllDummyRanges, propagatesRangeType,
ReturnBy;
foreach (DummyType; AllDummyRanges)
{
static if (!isBidirectionalRange!DummyType)
{
static assert(!__traits(compiles, Retro!DummyType));
}
else
{
DummyType dummyRange;
dummyRange.reinit();
auto myRetro = retro(dummyRange);
static assert(propagatesRangeType!(typeof(myRetro), DummyType));
assert(myRetro.front == 10);
assert(myRetro.back == 1);
assert(myRetro.moveFront() == 10);
assert(myRetro.moveBack() == 1);
static if (isRandomAccessRange!DummyType && hasLength!DummyType)
{
assert(myRetro[0] == myRetro.front);
assert(myRetro.moveAt(2) == 8);
static if (DummyType.r == ReturnBy.Reference)
{
{
myRetro[9]++;
scope(exit) myRetro[9]--;
assert(dummyRange[0] == 2);
myRetro.front++;
scope(exit) myRetro.front--;
assert(myRetro.front == 11);
myRetro.back++;
scope(exit) myRetro.back--;
assert(myRetro.back == 3);
}
{
myRetro.front = 0xFF;
scope(exit) myRetro.front = 10;
assert(dummyRange.back == 0xFF);
myRetro.back = 0xBB;
scope(exit) myRetro.back = 1;
assert(dummyRange.front == 0xBB);
myRetro[1] = 11;
scope(exit) myRetro[1] = 8;
assert(dummyRange[8] == 11);
}
}
}
}
}
}
pure @safe nothrow @nogc unittest
{
import std.algorithm.comparison : equal;
auto LL = iota(1L, 4L);
auto r = retro(LL);
long[3] excepted = [3, 2, 1];
assert(equal(r, excepted[]));
}
// Issue 12662
pure @safe nothrow @nogc unittest
{
int[3] src = [1,2,3];
int[] data = src[];
foreach_reverse (x; data) {}
foreach (x; data.retro) {}
}
/**
Iterates range `r` with stride `n`. If the range is a
random-access range, moves by indexing into the range; otherwise,
moves by successive calls to `popFront`. Applying stride twice to
the same range results in a stride with a step that is the
product of the two applications. It is an error for `n` to be 0.
Params:
r = the $(REF_ALTTEXT input range, isInputRange, std,range,primitives) to stride over
n = the number of elements to skip over
Returns:
At minimum, an input range. The resulting range will adopt the
range primitives of the underlying range as long as
$(REF hasLength, std,range,primitives) is `true`.
*/
auto stride(Range)(Range r, size_t n)
if (isInputRange!(Unqual!Range))
in
{
assert(n != 0, "stride cannot have step zero.");
}
do
{
import std.algorithm.comparison : min;
static if (is(typeof(stride(r.source, n)) == Range))
{
// stride(stride(r, n1), n2) is stride(r, n1 * n2)
return stride(r.source, r._n * n);
}
else
{
static struct Result
{
private alias R = Unqual!Range;
public R source;
private size_t _n;
// Chop off the slack elements at the end
static if (hasLength!R &&
(isRandomAccessRange!R && hasSlicing!R
|| isBidirectionalRange!R))
private void eliminateSlackElements()
{
auto slack = source.length % _n;
if (slack)
{
slack--;
}
else if (!source.empty)
{
slack = min(_n, source.length) - 1;
}
else
{
slack = 0;
}
if (!slack) return;
static if (isRandomAccessRange!R && hasLength!R && hasSlicing!R)
{
source = source[0 .. source.length - slack];
}
else static if (isBidirectionalRange!R)
{
foreach (i; 0 .. slack)
{
source.popBack();
}
}
}
static if (isForwardRange!R)
{
@property auto save()
{
return Result(source.save, _n);
}
}
static if (isInfinite!R)
{
enum bool empty = false;
}
else
{
@property bool empty()
{
return source.empty;
}
}
@property auto ref front()
{
return source.front;
}
static if (is(typeof(.moveFront(source))))
{
ElementType!R moveFront()
{
return source.moveFront();
}
}
static if (hasAssignableElements!R)
{
@property void front(ElementType!R val)
{
source.front = val;
}
}
void popFront()
{
source.popFrontN(_n);
}
static if (isBidirectionalRange!R && hasLength!R)
{
void popBack()
{
popBackN(source, _n);
}
@property auto ref back()
{
eliminateSlackElements();
return source.back;
}
static if (is(typeof(.moveBack(source))))
{
ElementType!R moveBack()
{
eliminateSlackElements();
return source.moveBack();
}
}
static if (hasAssignableElements!R)
{
@property void back(ElementType!R val)
{
eliminateSlackElements();
source.back = val;
}
}
}
static if (isRandomAccessRange!R && hasLength!R)
{
auto ref opIndex(size_t n)
{
return source[_n * n];
}
/**
Forwards to $(D moveAt(source, n)).
*/
static if (is(typeof(source.moveAt(0))))
{
ElementType!R moveAt(size_t n)
{
return source.moveAt(_n * n);
}
}
static if (hasAssignableElements!R)
{
void opIndexAssign(ElementType!R val, size_t n)
{
source[_n * n] = val;
}
}
}
static if (hasSlicing!R && hasLength!R)
typeof(this) opSlice(size_t lower, size_t upper)
{
assert(upper >= lower && upper <= length);
immutable translatedUpper = (upper == 0) ? 0 :
(upper * _n - (_n - 1));
immutable translatedLower = min(lower * _n, translatedUpper);
assert(translatedLower <= translatedUpper);
return typeof(this)(source[translatedLower .. translatedUpper], _n);
}
static if (hasLength!R)
{
@property auto length()
{
return (source.length + _n - 1) / _n;
}
alias opDollar = length;
}
}
return Result(r, n);
}
}
///
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
int[] a = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ];
assert(equal(stride(a, 3), [ 1, 4, 7, 10 ][]));
assert(stride(stride(a, 2), 3) == stride(a, 6));
}
pure @safe nothrow @nogc unittest
{
import std.algorithm.comparison : equal;
int[4] testArr = [1,2,3,4];
static immutable result = [1, 3];
assert(equal(testArr[].stride(2), result));
}
debug pure nothrow @system unittest
{//check the contract
int[4] testArr = [1,2,3,4];
bool passed = false;
scope (success) assert(passed);
import core.exception : AssertError;
//std.exception.assertThrown won't do because it can't infer nothrow
// @@@BUG@@@ 12647
try
{
auto unused = testArr[].stride(0);
}
catch (AssertError unused)
{
passed = true;
}
}
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges, propagatesRangeType,
ReturnBy;
static assert(isRandomAccessRange!(typeof(stride([1, 2, 3], 2))));
void test(size_t n, int[] input, int[] witness)
{
assert(equal(stride(input, n), witness));
}
test(1, [], []);
int[] arr = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
assert(stride(stride(arr, 2), 3) is stride(arr, 6));
test(1, arr, arr);
test(2, arr, [1, 3, 5, 7, 9]);
test(3, arr, [1, 4, 7, 10]);
test(4, arr, [1, 5, 9]);
// Test slicing.
auto s1 = stride(arr, 1);
assert(equal(s1[1 .. 4], [2, 3, 4]));
assert(s1[1 .. 4].length == 3);
assert(equal(s1[1 .. 5], [2, 3, 4, 5]));
assert(s1[1 .. 5].length == 4);
assert(s1[0 .. 0].empty);
assert(s1[3 .. 3].empty);
// assert(s1[$ .. $].empty);
assert(s1[s1.opDollar .. s1.opDollar].empty);
auto s2 = stride(arr, 2);
assert(equal(s2[0 .. 2], [1,3]));
assert(s2[0 .. 2].length == 2);
assert(equal(s2[1 .. 5], [3, 5, 7, 9]));
assert(s2[1 .. 5].length == 4);
assert(s2[0 .. 0].empty);
assert(s2[3 .. 3].empty);
// assert(s2[$ .. $].empty);
assert(s2[s2.opDollar .. s2.opDollar].empty);
// Test fix for Bug 5035
auto m = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]; // 3 rows, 4 columns
auto col = stride(m, 4);
assert(equal(col, [1, 1, 1]));
assert(equal(retro(col), [1, 1, 1]));
immutable int[] immi = [ 1, 2, 3 ];
static assert(isRandomAccessRange!(typeof(stride(immi, 1))));
// Check for infiniteness propagation.
static assert(isInfinite!(typeof(stride(repeat(1), 3))));
foreach (DummyType; AllDummyRanges)
{
DummyType dummyRange;
dummyRange.reinit();
auto myStride = stride(dummyRange, 4);
// Should fail if no length and bidirectional b/c there's no way
// to know how much slack we have.
static if (hasLength!DummyType || !isBidirectionalRange!DummyType)
{
static assert(propagatesRangeType!(typeof(myStride), DummyType));
}
assert(myStride.front == 1);
assert(myStride.moveFront() == 1);
assert(equal(myStride, [1, 5, 9]));
static if (hasLength!DummyType)
{
assert(myStride.length == 3);
}
static if (isBidirectionalRange!DummyType && hasLength!DummyType)
{
assert(myStride.back == 9);
assert(myStride.moveBack() == 9);
}
static if (isRandomAccessRange!DummyType && hasLength!DummyType)
{
assert(myStride[0] == 1);
assert(myStride[1] == 5);
assert(myStride.moveAt(1) == 5);
assert(myStride[2] == 9);
static assert(hasSlicing!(typeof(myStride)));
}
static if (DummyType.r == ReturnBy.Reference)
{
// Make sure reference is propagated.
{
myStride.front++;
scope(exit) myStride.front--;
assert(dummyRange.front == 2);
}
{
myStride.front = 4;
scope(exit) myStride.front = 1;
assert(dummyRange.front == 4);
}
static if (isBidirectionalRange!DummyType && hasLength!DummyType)
{
{
myStride.back++;
scope(exit) myStride.back--;
assert(myStride.back == 10);
}
{
myStride.back = 111;
scope(exit) myStride.back = 9;
assert(myStride.back == 111);
}
static if (isRandomAccessRange!DummyType)
{
{
myStride[1]++;
scope(exit) myStride[1]--;
assert(dummyRange[4] == 6);
}
{
myStride[1] = 55;
scope(exit) myStride[1] = 5;
assert(dummyRange[4] == 55);
}
}
}
}
}
}
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
auto LL = iota(1L, 10L);
auto s = stride(LL, 3);
assert(equal(s, [1L, 4L, 7L]));
}
/**
Spans multiple ranges in sequence. The function `chain` takes any
number of ranges and returns a $(D Chain!(R1, R2,...)) object. The
ranges may be different, but they must have the same element type. The
result is a range that offers the `front`, `popFront`, and $(D
empty) primitives. If all input ranges offer random access and $(D
length), `Chain` offers them as well.
If only one range is offered to `Chain` or `chain`, the $(D
Chain) type exits the picture by aliasing itself directly to that
range's type.
Params:
rs = the $(REF_ALTTEXT input ranges, isInputRange, std,range,primitives) to chain together
Returns:
An input range at minimum. If all of the ranges in `rs` provide
a range primitive, the returned range will also provide that range
primitive.
See_Also: $(LREF only) to chain values to a range
*/
auto chain(Ranges...)(Ranges rs)
if (Ranges.length > 0 &&
allSatisfy!(isInputRange, staticMap!(Unqual, Ranges)) &&
!is(CommonType!(staticMap!(ElementType, staticMap!(Unqual, Ranges))) == void))
{
static if (Ranges.length == 1)
{
return rs[0];
}
else
{
static struct Result
{
private:
alias R = staticMap!(Unqual, Ranges);
alias RvalueElementType = CommonType!(staticMap!(.ElementType, R));
private template sameET(A)
{
enum sameET = is(.ElementType!A == RvalueElementType);
}
enum bool allSameType = allSatisfy!(sameET, R);
// This doesn't work yet
static if (allSameType)
{
alias ElementType = ref RvalueElementType;
}
else
{
alias ElementType = RvalueElementType;
}
static if (allSameType && allSatisfy!(hasLvalueElements, R))
{
static ref RvalueElementType fixRef(ref RvalueElementType val)
{
return val;
}
}
else
{
static RvalueElementType fixRef(RvalueElementType val)
{
return val;
}
}
// This is the entire state
R source;
// TODO: use a vtable (or more) instead of linear iteration
public:
this(R input)
{
foreach (i, v; input)
{
source[i] = v;
}
}
import std.meta : anySatisfy;
static if (anySatisfy!(isInfinite, R))
{
// Propagate infiniteness.
enum bool empty = false;
}
else
{
@property bool empty()
{
foreach (i, Unused; R)
{
if (!source[i].empty) return false;
}
return true;
}
}
static if (allSatisfy!(isForwardRange, R))
@property auto save()
{
auto saveSource(size_t len)()
{
import std.typecons : tuple;
static assert(len > 0);
static if (len == 1)
{
return tuple(source[0].save);
}
else
{
return saveSource!(len - 1)() ~
tuple(source[len - 1].save);
}
}
return Result(saveSource!(R.length).expand);
}
void popFront()
{
foreach (i, Unused; R)
{
if (source[i].empty) continue;
source[i].popFront();
return;
}
}
@property auto ref front()
{
foreach (i, Unused; R)
{
if (source[i].empty) continue;
return fixRef(source[i].front);
}
assert(false);
}
static if (allSameType && allSatisfy!(hasAssignableElements, R))
{
// @@@BUG@@@
//@property void front(T)(T v) if (is(T : RvalueElementType))
@property void front(RvalueElementType v)
{
foreach (i, Unused; R)
{
if (source[i].empty) continue;
source[i].front = v;
return;
}
assert(false);
}
}
static if (allSatisfy!(hasMobileElements, R))
{
RvalueElementType moveFront()
{
foreach (i, Unused; R)
{
if (source[i].empty) continue;
return source[i].moveFront();
}
assert(false);
}
}
static if (allSatisfy!(isBidirectionalRange, R))
{
@property auto ref back()
{
foreach_reverse (i, Unused; R)
{
if (source[i].empty) continue;
return fixRef(source[i].back);
}
assert(false);
}
void popBack()
{
foreach_reverse (i, Unused; R)
{
if (source[i].empty) continue;
source[i].popBack();
return;
}
}
static if (allSatisfy!(hasMobileElements, R))
{
RvalueElementType moveBack()
{
foreach_reverse (i, Unused; R)
{
if (source[i].empty) continue;
return source[i].moveBack();
}
assert(false);
}
}
static if (allSameType && allSatisfy!(hasAssignableElements, R))
{
@property void back(RvalueElementType v)
{
foreach_reverse (i, Unused; R)
{
if (source[i].empty) continue;
source[i].back = v;
return;
}
assert(false);
}
}
}
static if (allSatisfy!(hasLength, R))
{
@property size_t length()
{
size_t result;
foreach (i, Unused; R)
{
result += source[i].length;
}
return result;
}
alias opDollar = length;
}
static if (allSatisfy!(isRandomAccessRange, R))
{
auto ref opIndex(size_t index)
{
foreach (i, Range; R)
{
static if (isInfinite!(Range))
{
return source[i][index];
}
else
{
immutable length = source[i].length;
if (index < length) return fixRef(source[i][index]);
index -= length;
}
}
assert(false);
}
static if (allSatisfy!(hasMobileElements, R))
{
RvalueElementType moveAt(size_t index)
{
foreach (i, Range; R)
{
static if (isInfinite!(Range))
{
return source[i].moveAt(index);
}
else
{
immutable length = source[i].length;
if (index < length) return source[i].moveAt(index);
index -= length;
}
}
assert(false);
}
}
static if (allSameType && allSatisfy!(hasAssignableElements, R))
void opIndexAssign(ElementType v, size_t index)
{
foreach (i, Range; R)
{
static if (isInfinite!(Range))
{
source[i][index] = v;
}
else
{
immutable length = source[i].length;
if (index < length)
{
source[i][index] = v;
return;
}
index -= length;
}
}
assert(false);
}
}
static if (allSatisfy!(hasLength, R) && allSatisfy!(hasSlicing, R))
auto opSlice(size_t begin, size_t end) return scope
{
auto result = this;
foreach (i, Unused; R)
{
immutable len = result.source[i].length;
if (len < begin)
{
result.source[i] = result.source[i]
[len .. len];
begin -= len;
}
else
{
result.source[i] = result.source[i]
[begin .. len];
break;
}
}
auto cut = length;
cut = cut <= end ? 0 : cut - end;
foreach_reverse (i, Unused; R)
{
immutable len = result.source[i].length;
if (cut > len)
{
result.source[i] = result.source[i]
[0 .. 0];
cut -= len;
}
else
{
result.source[i] = result.source[i]
[0 .. len - cut];
break;
}
}
return result;
}
}
return Result(rs);
}
}
///
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
int[] arr1 = [ 1, 2, 3, 4 ];
int[] arr2 = [ 5, 6 ];
int[] arr3 = [ 7 ];
auto s = chain(arr1, arr2, arr3);
assert(s.length == 7);
assert(s[5] == 6);
assert(equal(s, [1, 2, 3, 4, 5, 6, 7][]));
}
/**
* Range primitives are carried over to the returned range if
* all of the ranges provide them
*/
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.sorting : sort;
int[] arr1 = [5, 2, 8];
int[] arr2 = [3, 7, 9];
int[] arr3 = [1, 4, 6];
// in-place sorting across all of the arrays
auto s = arr1.chain(arr2, arr3).sort;
assert(s.equal([1, 2, 3, 4, 5, 6, 7, 8, 9]));
assert(arr1.equal([1, 2, 3]));
assert(arr2.equal([4, 5, 6]));
assert(arr3.equal([7, 8, 9]));
}
/**
Due to safe type promotion in D, chaining together different
character ranges results in a `uint` range.
Use $(REF_ALTTEXT byChar, byChar,std,utf), $(REF_ALTTEXT byWchar, byWchar,std,utf),
and $(REF_ALTTEXT byDchar, byDchar,std,utf) on the ranges
to get the type you need.
*/
pure @safe nothrow unittest
{
import std.utf : byChar, byCodeUnit;
auto s1 = "string one";
auto s2 = "string two";
// s1 and s2 front is dchar because of auto-decoding
static assert(is(typeof(s1.front) == dchar) && is(typeof(s2.front) == dchar));
auto r1 = s1.chain(s2);
// chains of ranges of the same character type give that same type
static assert(is(typeof(r1.front) == dchar));
auto s3 = "string three".byCodeUnit;
static assert(is(typeof(s3.front) == immutable char));
auto r2 = s1.chain(s3);
// chaining ranges of mixed character types gives `dchar`
static assert(is(typeof(r2.front) == dchar));
// use byChar on character ranges to correctly convert them to UTF-8
auto r3 = s1.byChar.chain(s3);
static assert(is(typeof(r3.front) == immutable char));
}
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges, dummyLength,
propagatesRangeType;
{
int[] arr1 = [ 1, 2, 3, 4 ];
int[] arr2 = [ 5, 6 ];
int[] arr3 = [ 7 ];
int[] witness = [ 1, 2, 3, 4, 5, 6, 7 ];
auto s1 = chain(arr1);
static assert(isRandomAccessRange!(typeof(s1)));
auto s2 = chain(arr1, arr2);
static assert(isBidirectionalRange!(typeof(s2)));
static assert(isRandomAccessRange!(typeof(s2)));
s2.front = 1;
auto s = chain(arr1, arr2, arr3);
assert(s[5] == 6);
assert(equal(s, witness));
assert(s[5] == 6);
}
{
int[] arr1 = [ 1, 2, 3, 4 ];
int[] witness = [ 1, 2, 3, 4 ];
assert(equal(chain(arr1), witness));
}
{
uint[] foo = [1,2,3,4,5];
uint[] bar = [1,2,3,4,5];
auto c = chain(foo, bar);
c[3] = 42;
assert(c[3] == 42);
assert(c.moveFront() == 1);
assert(c.moveBack() == 5);
assert(c.moveAt(4) == 5);
assert(c.moveAt(5) == 1);
}
// Make sure bug 3311 is fixed. ChainImpl should compile even if not all
// elements are mutable.
assert(equal(chain(iota(0, 3), iota(0, 3)), [0, 1, 2, 0, 1, 2]));
// Test the case where infinite ranges are present.
auto inf = chain([0,1,2][], cycle([4,5,6][]), [7,8,9][]); // infinite range
assert(inf[0] == 0);
assert(inf[3] == 4);
assert(inf[6] == 4);
assert(inf[7] == 5);
static assert(isInfinite!(typeof(inf)));
immutable int[] immi = [ 1, 2, 3 ];
immutable float[] immf = [ 1, 2, 3 ];
static assert(is(typeof(chain(immi, immf))));
// Check that chain at least instantiates and compiles with every possible
// pair of DummyRange types, in either order.
foreach (DummyType1; AllDummyRanges)
(){ // workaround slow optimizations for large functions @@@BUG@@@ 2396
DummyType1 dummy1;
foreach (DummyType2; AllDummyRanges)
{
DummyType2 dummy2;
auto myChain = chain(dummy1, dummy2);
static assert(
propagatesRangeType!(typeof(myChain), DummyType1, DummyType2)
);
assert(myChain.front == 1);
foreach (i; 0 .. dummyLength)
{
myChain.popFront();
}
assert(myChain.front == 1);
static if (isBidirectionalRange!DummyType1 &&
isBidirectionalRange!DummyType2) {
assert(myChain.back == 10);
}
static if (isRandomAccessRange!DummyType1 &&
isRandomAccessRange!DummyType2) {
assert(myChain[0] == 1);
}
static if (hasLvalueElements!DummyType1 && hasLvalueElements!DummyType2)
{
static assert(hasLvalueElements!(typeof(myChain)));
}
else
{
static assert(!hasLvalueElements!(typeof(myChain)));
}
}
}();
}
pure @safe nothrow @nogc unittest
{
class Foo{}
immutable(Foo)[] a;
immutable(Foo)[] b;
assert(chain(a, b).empty);
}
pure @safe unittest // issue 18657
{
import std.algorithm.comparison : equal;
string s = "foo";
auto r = refRange(&s).chain("bar");
assert(equal(r.save, "foobar"));
assert(equal(r, "foobar"));
}
/**
Choose one of two ranges at runtime depending on a Boolean condition.
The ranges may be different, but they must have compatible element types (i.e.
`CommonType` must exist for the two element types). The result is a range
that offers the weakest capabilities of the two (e.g. `ForwardRange` if $(D
R1) is a random-access range and `R2` is a forward range).
Params:
condition = which range to choose: `r1` if `true`, `r2` otherwise
r1 = the "true" range
r2 = the "false" range
Returns:
A range type dependent on `R1` and `R2`.
*/
auto choose(R1, R2)(bool condition, return scope R1 r1, return scope R2 r2)
if (isInputRange!(Unqual!R1) && isInputRange!(Unqual!R2) &&
!is(CommonType!(ElementType!(Unqual!R1), ElementType!(Unqual!R2)) == void))
{
return ChooseResult!(R1, R2)(condition, r1, r2);
}
///
@safe nothrow pure @nogc unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filter, map;
auto data1 = only(1, 2, 3, 4).filter!(a => a != 3);
auto data2 = only(5, 6, 7, 8).map!(a => a + 1);
// choose() is primarily useful when you need to select one of two ranges
// with different types at runtime.
static assert(!is(typeof(data1) == typeof(data2)));
auto chooseRange(bool pickFirst)
{
// The returned range is a common wrapper type that can be used for
// returning or storing either range without running into a type error.
return choose(pickFirst, data1, data2);
// Simply returning the chosen range without using choose() does not
// work, because map() and filter() return different types.
//return pickFirst ? data1 : data2; // does not compile
}
auto result = chooseRange(true);
assert(result.equal(only(1, 2, 4)));
result = chooseRange(false);
assert(result.equal(only(6, 7, 8, 9)));
}
private struct ChooseResult(R1, R2)
{
import std.traits : hasElaborateCopyConstructor, hasElaborateDestructor;
private union
{
R1 r1;
R2 r2;
}
private bool r1Chosen;
private static auto ref actOnChosen(alias foo, ExtraArgs ...)(ref ChooseResult r,
auto ref ExtraArgs extraArgs)
{
if (r.r1Chosen)
{
ref get1(return ref ChooseResult r) @trusted { return r.r1; }
return foo(get1(r), extraArgs);
}
else
{
ref get2(return ref ChooseResult r) @trusted { return r.r2; }
return foo(get2(r), extraArgs);
}
}
this(bool r1Chosen, return scope R1 r1, return scope R2 r2) @trusted
{
// @trusted because of assignment of r1 and r2 which overlap each other
import std.conv : emplace;
// This should be the only place r1Chosen is ever assigned
// independently
this.r1Chosen = r1Chosen;
if (r1Chosen)
{
this.r2 = R2.init;
emplace(&this.r1, r1);
}
else
{
this.r1 = R1.init;
emplace(&this.r2, r2);
}
}
void opAssign(ChooseResult r)
{
static if (hasElaborateDestructor!R1 || hasElaborateDestructor!R2)
if (r1Chosen != r.r1Chosen)
{
// destroy the current item
actOnChosen!((ref r) => destroy(r))(this);
}
r1Chosen = r.r1Chosen;
if (r1Chosen)
{
ref get1(return ref ChooseResult r) @trusted { return r.r1; }
get1(this) = get1(r);
}
else
{
ref get2(return ref ChooseResult r) @trusted { return r.r2; }
get2(this) = get2(r);
}
}
// Carefully defined postblit to postblit the appropriate range
static if (hasElaborateCopyConstructor!R1
|| hasElaborateCopyConstructor!R2)
this(this)
{
actOnChosen!((ref r) {
static if (hasElaborateCopyConstructor!(typeof(r))) r.__postblit();
})(this);
}
static if (hasElaborateDestructor!R1 || hasElaborateDestructor!R2)
~this()
{
actOnChosen!((ref r) => destroy(r))(this);
}
static if (isInfinite!R1 && isInfinite!R2)
// Propagate infiniteness.
enum bool empty = false;
else
@property bool empty()
{
return actOnChosen!(r => r.empty)(this);
}
@property auto ref front()
{
static auto ref getFront(R)(ref R r) { return r.front; }
return actOnChosen!getFront(this);
}
void popFront()
{
return actOnChosen!((ref r) { r.popFront; })(this);
}
static if (isForwardRange!R1 && isForwardRange!R2)
@property auto save() return scope
{
if (r1Chosen)
{
ref R1 getR1() @trusted { return r1; }
return ChooseResult(r1Chosen, getR1.save, R2.init);
}
else
{
ref R2 getR2() @trusted { return r2; }
return ChooseResult(r1Chosen, R1.init, getR2.save);
}
}
@property void front(T)(T v)
if (is(typeof({ r1.front = v; r2.front = v; })))
{
actOnChosen!((ref r, T v) { r.front = v; })(this, v);
}
static if (hasMobileElements!R1 && hasMobileElements!R2)
auto moveFront()
{
return actOnChosen!((ref r) => r.moveFront)(this);
}
static if (isBidirectionalRange!R1 && isBidirectionalRange!R2)
{
@property auto ref back()
{
static auto ref getBack(R)(ref R r) { return r.back; }
return actOnChosen!getBack(this);
}
void popBack()
{
actOnChosen!((ref r) { r.popBack; })(this);
}
static if (hasMobileElements!R1 && hasMobileElements!R2)
auto moveBack()
{
return actOnChosen!((ref r) => r.moveBack)(this);
}
@property void back(T)(T v)
if (is(typeof({ r1.back = v; r2.back = v; })))
{
actOnChosen!((ref r, T v) { r.back = v; })(this, v);
}
}
static if (hasLength!R1 && hasLength!R2)
{
@property size_t length()
{
return actOnChosen!(r => r.length)(this);
}
alias opDollar = length;
}
static if (isRandomAccessRange!R1 && isRandomAccessRange!R2)
{
auto ref opIndex(size_t index)
{
static auto ref get(R)(ref R r, size_t index) { return r[index]; }
return actOnChosen!get(this, index);
}
static if (hasMobileElements!R1 && hasMobileElements!R2)
auto moveAt(size_t index)
{
return actOnChosen!((ref r, size_t index) => r.moveAt(index))
(this, index);
}
void opIndexAssign(T)(T v, size_t index)
if (is(typeof({ r1[1] = v; r2[1] = v; })))
{
return actOnChosen!((ref r, size_t index, T v) { r[index] = v; })
(this, index, v);
}
}
static if (hasSlicing!R1 && hasSlicing!R2)
auto opSlice(size_t begin, size_t end)
{
alias Slice1 = typeof(R1.init[0 .. 1]);
alias Slice2 = typeof(R2.init[0 .. 1]);
return actOnChosen!((r, size_t begin, size_t end) {
static if (is(typeof(r) == Slice1))
return choose(true, r[begin .. end], Slice2.init);
else
return choose(false, Slice1.init, r[begin .. end]);
})(this, begin, end);
}
}
pure @safe unittest // issue 18657
{
import std.algorithm.comparison : equal;
string s = "foo";
auto r = choose(true, refRange(&s), "bar");
assert(equal(r.save, "foo"));
assert(equal(r, "foo"));
}
@safe unittest
{
static void* p;
static struct R
{
void* q;
int front;
bool empty;
void popFront() {}
@property R save() { p = q; return this; }
// `p = q;` is only there to prevent inference of `scope return`.
}
R r;
choose(true, r, r).save;
}
// Make sure ChooseResult.save doesn't trust @system user code.
@system unittest // copy is @system
{
static struct R
{
int front;
bool empty;
void popFront() {}
this(this) @system {}
@property R save() { return R(front, empty); }
}
choose(true, R(), R()).save;
choose(true, [0], R()).save;
choose(true, R(), [0]).save;
}
@safe unittest // copy is @system
{
static struct R
{
int front;
bool empty;
void popFront() {}
this(this) @system {}
@property R save() { return R(front, empty); }
}
static assert(!__traits(compiles, choose(true, R(), R()).save));
static assert(!__traits(compiles, choose(true, [0], R()).save));
static assert(!__traits(compiles, choose(true, R(), [0]).save));
}
@system unittest // .save is @system
{
static struct R
{
int front;
bool empty;
void popFront() {}
@property R save() @system { return this; }
}
choose(true, R(), R()).save;
choose(true, [0], R()).save;
choose(true, R(), [0]).save;
}
@safe unittest // .save is @system
{
static struct R
{
int front;
bool empty;
void popFront() {}
@property R save() @system { return this; }
}
static assert(!__traits(compiles, choose(true, R(), R()).save));
static assert(!__traits(compiles, choose(true, [0], R()).save));
static assert(!__traits(compiles, choose(true, R(), [0]).save));
}
//https://issues.dlang.org/show_bug.cgi?id=19738
@safe nothrow pure @nogc unittest
{
static struct EvilRange
{
enum empty = true;
int front;
void popFront() @safe {}
auto opAssign(const ref EvilRange other)
{
*(cast(uint*) 0xcafebabe) = 0xdeadbeef;
return this;
}
}
static assert(!__traits(compiles, () @safe
{
auto c1 = choose(true, EvilRange(), EvilRange());
auto c2 = c1;
c1 = c2;
}));
}
@safe unittest // issue 20495
{
static struct KillableRange
{
int *item;
ref int front() { return *item; }
bool empty() { return *item > 10; }
void popFront() { ++(*item); }
this(this)
{
assert(item is null || cast(size_t) item > 1000);
item = new int(*item);
}
KillableRange save() { return this; }
}
auto kr = KillableRange(new int(1));
int[] x = [1,2,3,4,5]; // length is first
auto chosen = choose(true, x, kr);
auto chosen2 = chosen.save;
}
/**
Choose one of multiple ranges at runtime.
The ranges may be different, but they must have compatible element types. The
result is a range that offers the weakest capabilities of all `Ranges`.
Params:
index = which range to choose, must be less than the number of ranges
rs = two or more ranges
Returns:
The indexed range. If rs consists of only one range, the return type is an
alias of that range's type.
*/
auto chooseAmong(Ranges...)(size_t index, return scope Ranges rs)
if (Ranges.length >= 2
&& allSatisfy!(isInputRange, staticMap!(Unqual, Ranges))
&& !is(CommonType!(staticMap!(ElementType, Ranges)) == void))
{
static if (Ranges.length == 2)
return choose(index == 0, rs[0], rs[1]);
else
return choose(index == 0, rs[0], chooseAmong(index - 1, rs[1 .. $]));
}
///
@safe nothrow pure @nogc unittest
{
auto test()
{
import std.algorithm.comparison : equal;
int[4] sarr1 = [1, 2, 3, 4];
int[2] sarr2 = [5, 6];
int[1] sarr3 = [7];
auto arr1 = sarr1[];
auto arr2 = sarr2[];
auto arr3 = sarr3[];
{
auto s = chooseAmong(0, arr1, arr2, arr3);
auto t = s.save;
assert(s.length == 4);
assert(s[2] == 3);
s.popFront();
assert(equal(t, only(1, 2, 3, 4)));
}
{
auto s = chooseAmong(1, arr1, arr2, arr3);
assert(s.length == 2);
s.front = 8;
assert(equal(s, only(8, 6)));
}
{
auto s = chooseAmong(1, arr1, arr2, arr3);
assert(s.length == 2);
s[1] = 9;
assert(equal(s, only(8, 9)));
}
{
auto s = chooseAmong(1, arr2, arr1, arr3)[1 .. 3];
assert(s.length == 2);
assert(equal(s, only(2, 3)));
}
{
auto s = chooseAmong(0, arr1, arr2, arr3);
assert(s.length == 4);
assert(s.back == 4);
s.popBack();
s.back = 5;
assert(equal(s, only(1, 2, 5)));
s.back = 3;
assert(equal(s, only(1, 2, 3)));
}
{
uint[5] foo = [1, 2, 3, 4, 5];
uint[5] bar = [6, 7, 8, 9, 10];
auto c = chooseAmong(1, foo[], bar[]);
assert(c[3] == 9);
c[3] = 42;
assert(c[3] == 42);
assert(c.moveFront() == 6);
assert(c.moveBack() == 10);
assert(c.moveAt(4) == 10);
}
{
import std.range : cycle;
auto s = chooseAmong(0, cycle(arr2), cycle(arr3));
assert(isInfinite!(typeof(s)));
assert(!s.empty);
assert(s[100] == 8);
assert(s[101] == 9);
assert(s[0 .. 3].equal(only(8, 9, 8)));
}
return 0;
}
// works at runtime
auto a = test();
// and at compile time
static b = test();
}
@safe nothrow pure @nogc unittest
{
int[3] a = [1, 2, 3];
long[3] b = [4, 5, 6];
auto c = chooseAmong(0, a[], b[]);
c[0] = 42;
assert(c[0] == 42);
}
@safe nothrow pure @nogc unittest
{
static struct RefAccessRange
{
int[] r;
ref front() @property { return r[0]; }
ref back() @property { return r[$ - 1]; }
void popFront() { r = r[1 .. $]; }
void popBack() { r = r[0 .. $ - 1]; }
auto empty() @property { return r.empty; }
ref opIndex(size_t i) { return r[i]; }
auto length() @property { return r.length; }
alias opDollar = length;
auto save() { return this; }
}
static assert(isRandomAccessRange!RefAccessRange);
static assert(isRandomAccessRange!RefAccessRange);
int[4] a = [4, 3, 2, 1];
int[2] b = [6, 5];
auto c = chooseAmong(0, RefAccessRange(a[]), RefAccessRange(b[]));
void refFunc(ref int a, int target) { assert(a == target); }
refFunc(c[2], 2);
refFunc(c.front, 4);
refFunc(c.back, 1);
}
/**
$(D roundRobin(r1, r2, r3)) yields `r1.front`, then `r2.front`,
then `r3.front`, after which it pops off one element from each and
continues again from `r1`. For example, if two ranges are involved,
it alternately yields elements off the two ranges. `roundRobin`
stops after it has consumed all ranges (skipping over the ones that
finish early).
*/
auto roundRobin(Rs...)(Rs rs)
if (Rs.length > 1 && allSatisfy!(isInputRange, staticMap!(Unqual, Rs)))
{
struct Result
{
import std.conv : to;
public Rs source;
private size_t _current = size_t.max;
@property bool empty()
{
foreach (i, Unused; Rs)
{
if (!source[i].empty) return false;
}
return true;
}
@property auto ref front()
{
final switch (_current)
{
foreach (i, R; Rs)
{
case i:
assert(
!source[i].empty,
"Attempting to fetch the front of an empty roundRobin"
);
return source[i].front;
}
}
assert(0);
}
void popFront()
{
final switch (_current)
{
foreach (i, R; Rs)
{
case i:
source[i].popFront();
break;
}
}
auto next = _current == (Rs.length - 1) ? 0 : (_current + 1);
final switch (next)
{
foreach (i, R; Rs)
{
case i:
if (!source[i].empty)
{
_current = i;
return;
}
if (i == _current)
{
_current = _current.max;
return;
}
goto case (i + 1) % Rs.length;
}
}
}
static if (allSatisfy!(isForwardRange, staticMap!(Unqual, Rs)))
@property auto save()
{
auto saveSource(size_t len)()
{
import std.typecons : tuple;
static assert(len > 0);
static if (len == 1)
{
return tuple(source[0].save);
}
else
{
return saveSource!(len - 1)() ~
tuple(source[len - 1].save);
}
}
return Result(saveSource!(Rs.length).expand, _current);
}
static if (allSatisfy!(hasLength, Rs))
{
@property size_t length()
{
size_t result;
foreach (i, R; Rs)
{
result += source[i].length;
}
return result;
}
alias opDollar = length;
}
}
return Result(rs, 0);
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
int[] a = [ 1, 2, 3 ];
int[] b = [ 10, 20, 30, 40 ];
auto r = roundRobin(a, b);
assert(equal(r, [ 1, 10, 2, 20, 3, 30, 40 ]));
}
/**
* roundRobin can be used to create "interleave" functionality which inserts
* an element between each element in a range.
*/
@safe unittest
{
import std.algorithm.comparison : equal;
auto interleave(R, E)(R range, E element)
if ((isInputRange!R && hasLength!R) || isForwardRange!R)
{
static if (hasLength!R)
immutable len = range.length;
else
immutable len = range.save.walkLength;
return roundRobin(
range,
element.repeat(len - 1)
);
}
assert(interleave([1, 2, 3], 0).equal([1, 0, 2, 0, 3]));
}
pure @safe unittest
{
import std.algorithm.comparison : equal;
string f = "foo", b = "bar";
auto r = roundRobin(refRange(&f), refRange(&b));
assert(equal(r.save, "fboaor"));
assert(equal(r.save, "fboaor"));
}
/**
Iterates a random-access range starting from a given point and
progressively extending left and right from that point. If no initial
point is given, iteration starts from the middle of the
range. Iteration spans the entire range.
When `startingIndex` is 0 the range will be fully iterated in order
and in reverse order when `r.length` is given.
Params:
r = a random access range with length and slicing
startingIndex = the index to begin iteration from
Returns:
A forward range with length
*/
auto radial(Range, I)(Range r, I startingIndex)
if (isRandomAccessRange!(Unqual!Range) && hasLength!(Unqual!Range) && hasSlicing!(Unqual!Range) && isIntegral!I)
{
if (startingIndex != r.length) ++startingIndex;
return roundRobin(retro(r[0 .. startingIndex]), r[startingIndex .. r.length]);
}
/// Ditto
auto radial(R)(R r)
if (isRandomAccessRange!(Unqual!R) && hasLength!(Unqual!R) && hasSlicing!(Unqual!R))
{
return .radial(r, (r.length - !r.empty) / 2);
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
int[] a = [ 1, 2, 3, 4, 5 ];
assert(equal(radial(a), [ 3, 4, 2, 5, 1 ]));
a = [ 1, 2, 3, 4 ];
assert(equal(radial(a), [ 2, 3, 1, 4 ]));
// If the left end is reached first, the remaining elements on the right
// are concatenated in order:
a = [ 0, 1, 2, 3, 4, 5 ];
assert(equal(radial(a, 1), [ 1, 2, 0, 3, 4, 5 ]));
// If the right end is reached first, the remaining elements on the left
// are concatenated in reverse order:
assert(equal(radial(a, 4), [ 4, 5, 3, 2, 1, 0 ]));
}
@safe unittest
{
import std.algorithm.comparison : equal;
import std.conv : text;
import std.exception : enforce;
import std.internal.test.dummyrange : DummyRange, Length, RangeType, ReturnBy;
void test(int[] input, int[] witness)
{
enforce(equal(radial(input), witness),
text(radial(input), " vs. ", witness));
}
test([], []);
test([ 1 ], [ 1 ]);
test([ 1, 2 ], [ 1, 2 ]);
test([ 1, 2, 3 ], [ 2, 3, 1 ]);
test([ 1, 2, 3, 4 ], [ 2, 3, 1, 4 ]);
test([ 1, 2, 3, 4, 5 ], [ 3, 4, 2, 5, 1 ]);
test([ 1, 2, 3, 4, 5, 6 ], [ 3, 4, 2, 5, 1, 6 ]);
int[] a = [ 1, 2, 3, 4, 5 ];
assert(equal(radial(a, 1), [ 2, 3, 1, 4, 5 ]));
assert(equal(radial(a, 0), [ 1, 2, 3, 4, 5 ])); // only right subrange
assert(equal(radial(a, a.length), [ 5, 4, 3, 2, 1 ])); // only left subrange
static assert(isForwardRange!(typeof(radial(a, 1))));
auto r = radial([1,2,3,4,5]);
for (auto rr = r.save; !rr.empty; rr.popFront())
{
assert(rr.front == moveFront(rr));
}
r.front = 5;
assert(r.front == 5);
// Test instantiation without lvalue elements.
DummyRange!(ReturnBy.Value, Length.Yes, RangeType.Random) dummy;
assert(equal(radial(dummy, 4), [5, 6, 4, 7, 3, 8, 2, 9, 1, 10]));
// immutable int[] immi = [ 1, 2 ];
// static assert(is(typeof(radial(immi))));
}
@safe unittest
{
import std.algorithm.comparison : equal;
auto LL = iota(1L, 6L);
auto r = radial(LL);
assert(equal(r, [3L, 4L, 2L, 5L, 1L]));
}
/**
Lazily takes only up to `n` elements of a range. This is
particularly useful when using with infinite ranges.
Unlike $(LREF takeExactly), `take` does not require that there
are `n` or more elements in `input`. As a consequence, length
information is not applied to the result unless `input` also has
length information.
Params:
input = an $(REF_ALTTEXT input range, isInputRange, std,range,primitives)
to iterate over up to `n` times
n = the number of elements to take
Returns:
At minimum, an input range. If the range offers random access
and `length`, `take` offers them as well.
*/
Take!R take(R)(R input, size_t n)
if (isInputRange!(Unqual!R))
{
alias U = Unqual!R;
static if (is(R T == Take!T))
{
import std.algorithm.comparison : min;
return R(input.source, min(n, input._maxAvailable));
}
else static if (!isInfinite!U && hasSlicing!U)
{
import std.algorithm.comparison : min;
return input[0 .. min(n, input.length)];
}
else
{
return Take!R(input, n);
}
}
/// ditto
struct Take(Range)
if (isInputRange!(Unqual!Range) &&
//take _cannot_ test hasSlicing on infinite ranges, because hasSlicing uses
//take for slicing infinite ranges.
!((!isInfinite!(Unqual!Range) && hasSlicing!(Unqual!Range)) || is(Range T == Take!T)))
{
private alias R = Unqual!Range;
/// User accessible in read and write
public R source;
private size_t _maxAvailable;
alias Source = R;
/// Range primitives
@property bool empty()
{
return _maxAvailable == 0 || source.empty;
}
/// ditto
@property auto ref front()
{
assert(!empty,
"Attempting to fetch the front of an empty "
~ Take.stringof);
return source.front;
}
/// ditto
void popFront()
{
assert(!empty,
"Attempting to popFront() past the end of a "
~ Take.stringof);
source.popFront();
--_maxAvailable;
}
static if (isForwardRange!R)
/// ditto
@property Take save()
{
return Take(source.save, _maxAvailable);
}
static if (hasAssignableElements!R)
/// ditto
@property void front(ElementType!R v)
{
assert(!empty,
"Attempting to assign to the front of an empty "
~ Take.stringof);
// This has to return auto instead of void because of Bug 4706.
source.front = v;
}
static if (hasMobileElements!R)
{
/// ditto
auto moveFront()
{
assert(!empty,
"Attempting to move the front of an empty "
~ Take.stringof);
return source.moveFront();
}
}
static if (isInfinite!R)
{
/// ditto
@property size_t length() const
{
return _maxAvailable;
}
/// ditto
alias opDollar = length;
//Note: Due to Take/hasSlicing circular dependency,
//This needs to be a restrained template.
/// ditto
auto opSlice()(size_t i, size_t j)
if (hasSlicing!R)
{
assert(i <= j, "Invalid slice bounds");
assert(j <= length, "Attempting to slice past the end of a "
~ Take.stringof);
return source[i .. j];
}
}
else static if (hasLength!R)
{
/// ditto
@property size_t length()
{
import std.algorithm.comparison : min;
return min(_maxAvailable, source.length);
}
alias opDollar = length;
}
static if (isRandomAccessRange!R)
{
/// ditto
void popBack()
{
assert(!empty,
"Attempting to popBack() past the beginning of a "
~ Take.stringof);
--_maxAvailable;
}
/// ditto
@property auto ref back()
{
assert(!empty,
"Attempting to fetch the back of an empty "
~ Take.stringof);
return source[this.length - 1];
}
/// ditto
auto ref opIndex(size_t index)
{
assert(index < length,
"Attempting to index out of the bounds of a "
~ Take.stringof);
return source[index];
}
static if (hasAssignableElements!R)
{
/// ditto
@property void back(ElementType!R v)
{
// This has to return auto instead of void because of Bug 4706.
assert(!empty,
"Attempting to assign to the back of an empty "
~ Take.stringof);
source[this.length - 1] = v;
}
/// ditto
void opIndexAssign(ElementType!R v, size_t index)
{
assert(index < length,
"Attempting to index out of the bounds of a "
~ Take.stringof);
source[index] = v;
}
}
static if (hasMobileElements!R)
{
/// ditto
auto moveBack()
{
assert(!empty,
"Attempting to move the back of an empty "
~ Take.stringof);
return source.moveAt(this.length - 1);
}
/// ditto
auto moveAt(size_t index)
{
assert(index < length,
"Attempting to index out of the bounds of a "
~ Take.stringof);
return source.moveAt(index);
}
}
}
/**
Access to maximal length of the range.
Note: the actual length of the range depends on the underlying range.
If it has fewer elements, it will stop before maxLength is reached.
*/
@property size_t maxLength() const
{
return _maxAvailable;
}
}
/// ditto
template Take(R)
if (isInputRange!(Unqual!R) &&
((!isInfinite!(Unqual!R) && hasSlicing!(Unqual!R)) || is(R T == Take!T)))
{
alias Take = R;
}
///
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
int[] arr1 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
auto s = take(arr1, 5);
assert(s.length == 5);
assert(s[4] == 5);
assert(equal(s, [ 1, 2, 3, 4, 5 ][]));
}
/**
* If the range runs out before `n` elements, `take` simply returns the entire
* range (unlike $(LREF takeExactly), which will cause an assertion failure if
* the range ends prematurely):
*/
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
int[] arr2 = [ 1, 2, 3 ];
auto t = take(arr2, 5);
assert(t.length == 3);
assert(equal(t, [ 1, 2, 3 ]));
}
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges;
int[] arr1 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
auto s = take(arr1, 5);
assert(s.length == 5);
assert(s[4] == 5);
assert(equal(s, [ 1, 2, 3, 4, 5 ][]));
assert(equal(retro(s), [ 5, 4, 3, 2, 1 ][]));
// Test fix for bug 4464.
static assert(is(typeof(s) == Take!(int[])));
static assert(is(typeof(s) == int[]));
// Test using narrow strings.
import std.exception : assumeWontThrow;
auto myStr = "This is a string.";
auto takeMyStr = take(myStr, 7);
assert(assumeWontThrow(equal(takeMyStr, "This is")));
// Test fix for bug 5052.
auto takeMyStrAgain = take(takeMyStr, 4);
assert(assumeWontThrow(equal(takeMyStrAgain, "This")));
static assert(is (typeof(takeMyStrAgain) == typeof(takeMyStr)));
takeMyStrAgain = take(takeMyStr, 10);
assert(assumeWontThrow(equal(takeMyStrAgain, "This is")));
foreach (DummyType; AllDummyRanges)
{
DummyType dummy;
auto t = take(dummy, 5);
alias T = typeof(t);
static if (isRandomAccessRange!DummyType)
{
static assert(isRandomAccessRange!T);
assert(t[4] == 5);
assert(moveAt(t, 1) == t[1]);
assert(t.back == moveBack(t));
}
else static if (isForwardRange!DummyType)
{
static assert(isForwardRange!T);
}
for (auto tt = t; !tt.empty; tt.popFront())
{
assert(tt.front == moveFront(tt));
}
// Bidirectional ranges can't be propagated properly if they don't
// also have random access.
assert(equal(t, [1,2,3,4,5]));
//Test that take doesn't wrap the result of take.
assert(take(t, 4) == take(dummy, 4));
}
immutable myRepeat = repeat(1);
static assert(is(Take!(typeof(myRepeat))));
}
pure @safe nothrow @nogc unittest
{
//check for correct slicing of Take on an infinite range
import std.algorithm.comparison : equal;
foreach (start; 0 .. 4)
foreach (stop; start .. 4)
assert(iota(4).cycle.take(4)[start .. stop]
.equal(iota(start, stop)));
}
pure @safe nothrow @nogc unittest
{
// Check that one can declare variables of all Take types,
// and that they match the return type of the corresponding
// take(). (See issue 4464.)
int[] r1;
Take!(int[]) t1;
t1 = take(r1, 1);
assert(t1.empty);
string r2;
Take!string t2;
t2 = take(r2, 1);
assert(t2.empty);
Take!(Take!string) t3;
t3 = take(t2, 1);
assert(t3.empty);
}
pure @safe nothrow @nogc unittest
{
alias R1 = typeof(repeat(1));
alias R2 = typeof(cycle([1]));
alias TR1 = Take!R1;
alias TR2 = Take!R2;
static assert(isBidirectionalRange!TR1);
static assert(isBidirectionalRange!TR2);
}
pure @safe nothrow @nogc unittest //12731
{
auto a = repeat(1);
auto s = a[1 .. 5];
s = s[1 .. 3];
assert(s.length == 2);
assert(s[0] == 1);
assert(s[1] == 1);
}
pure @safe nothrow @nogc unittest //13151
{
import std.algorithm.comparison : equal;
auto r = take(repeat(1, 4), 3);
assert(r.take(2).equal(repeat(1, 2)));
}
/**
Similar to $(LREF take), but assumes that `range` has at least $(D
n) elements. Consequently, the result of $(D takeExactly(range, n))
always defines the `length` property (and initializes it to `n`)
even when `range` itself does not define `length`.
The result of `takeExactly` is identical to that of $(LREF take) in
cases where the original range defines `length` or is infinite.
Unlike $(LREF take), however, it is illegal to pass a range with less than
`n` elements to `takeExactly`; this will cause an assertion failure.
*/
auto takeExactly(R)(R range, size_t n)
if (isInputRange!R)
{
static if (is(typeof(takeExactly(range._input, n)) == R))
{
assert(n <= range._n,
"Attempted to take more than the length of the range with takeExactly.");
// takeExactly(takeExactly(r, n1), n2) has the same type as
// takeExactly(r, n1) and simply returns takeExactly(r, n2)
range._n = n;
return range;
}
//Also covers hasSlicing!R for finite ranges.
else static if (hasLength!R)
{
assert(n <= range.length,
"Attempted to take more than the length of the range with takeExactly.");
return take(range, n);
}
else static if (isInfinite!R)
return Take!R(range, n);
else
{
static struct Result
{
R _input;
private size_t _n;
@property bool empty() const { return !_n; }
@property auto ref front()
{
assert(_n > 0, "front() on an empty " ~ Result.stringof);
return _input.front;
}
void popFront() { _input.popFront(); --_n; }
@property size_t length() const { return _n; }
alias opDollar = length;
@property auto _takeExactly_Result_asTake()
{
return take(_input, _n);
}
alias _takeExactly_Result_asTake this;
static if (isForwardRange!R)
@property auto save()
{
return Result(_input.save, _n);
}
static if (hasMobileElements!R)
{
auto moveFront()
{
assert(!empty,
"Attempting to move the front of an empty "
~ typeof(this).stringof);
return _input.moveFront();
}
}
static if (hasAssignableElements!R)
{
@property auto ref front(ElementType!R v)
{
assert(!empty,
"Attempting to assign to the front of an empty "
~ typeof(this).stringof);
return _input.front = v;
}
}
}
return Result(range, n);
}
}
///
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
auto a = [ 1, 2, 3, 4, 5 ];
auto b = takeExactly(a, 3);
assert(equal(b, [1, 2, 3]));
static assert(is(typeof(b.length) == size_t));
assert(b.length == 3);
assert(b.front == 1);
assert(b.back == 3);
}
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filter;
auto a = [ 1, 2, 3, 4, 5 ];
auto b = takeExactly(a, 3);
assert(equal(b, [1, 2, 3]));
auto c = takeExactly(b, 2);
assert(equal(c, [1, 2]));
auto d = filter!"a > 2"(a);
auto e = takeExactly(d, 3);
assert(equal(e, [3, 4, 5]));
static assert(is(typeof(e.length) == size_t));
assert(e.length == 3);
assert(e.front == 3);
assert(equal(takeExactly(e, 3), [3, 4, 5]));
}
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges;
auto a = [ 1, 2, 3, 4, 5 ];
//Test that take and takeExactly are the same for ranges which define length
//but aren't sliceable.
struct L
{
@property auto front() { return _arr[0]; }
@property bool empty() { return _arr.empty; }
void popFront() { _arr.popFront(); }
@property size_t length() { return _arr.length; }
int[] _arr;
}
static assert(is(typeof(take(L(a), 3)) == typeof(takeExactly(L(a), 3))));
assert(take(L(a), 3) == takeExactly(L(a), 3));
//Test that take and takeExactly are the same for ranges which are sliceable.
static assert(is(typeof(take(a, 3)) == typeof(takeExactly(a, 3))));
assert(take(a, 3) == takeExactly(a, 3));
//Test that take and takeExactly are the same for infinite ranges.
auto inf = repeat(1);
static assert(is(typeof(take(inf, 5)) == Take!(typeof(inf))));
assert(take(inf, 5) == takeExactly(inf, 5));
//Test that take and takeExactly are _not_ the same for ranges which don't
//define length.
static assert(!is(typeof(take(filter!"true"(a), 3)) == typeof(takeExactly(filter!"true"(a), 3))));
foreach (DummyType; AllDummyRanges)
{
{
DummyType dummy;
auto t = takeExactly(dummy, 5);
//Test that takeExactly doesn't wrap the result of takeExactly.
assert(takeExactly(t, 4) == takeExactly(dummy, 4));
}
static if (hasMobileElements!DummyType)
{
{
auto t = takeExactly(DummyType.init, 4);
assert(t.moveFront() == 1);
assert(equal(t, [1, 2, 3, 4]));
}
}
static if (hasAssignableElements!DummyType)
{
{
auto t = takeExactly(DummyType.init, 4);
t.front = 9;
assert(equal(t, [9, 2, 3, 4]));
}
}
}
}
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : DummyRange, Length, RangeType, ReturnBy;
alias DummyType = DummyRange!(ReturnBy.Value, Length.No, RangeType.Forward);
auto te = takeExactly(DummyType(), 5);
Take!DummyType t = te;
assert(equal(t, [1, 2, 3, 4, 5]));
assert(equal(t, te));
}
// https://issues.dlang.org/show_bug.cgi?id=18092
// can't combine take and takeExactly
@safe unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges;
static foreach (Range; AllDummyRanges)
{{
Range r;
assert(r.take(6).takeExactly(2).equal([1, 2]));
assert(r.takeExactly(6).takeExactly(2).equal([1, 2]));
assert(r.takeExactly(6).take(2).equal([1, 2]));
}}
}
/**
Returns a range with at most one element; for example, $(D
takeOne([42, 43, 44])) returns a range consisting of the integer $(D
42). Calling `popFront()` off that range renders it empty.
In effect `takeOne(r)` is somewhat equivalent to $(D take(r, 1)) but in
certain interfaces it is important to know statically that the range may only
have at most one element.
The type returned by `takeOne` is a random-access range with length
regardless of `R`'s capabilities, as long as it is a forward range.
(another feature that distinguishes `takeOne` from `take`). If
(D R) is an input range but not a forward range, return type is an input
range with all random-access capabilities except save.
*/
auto takeOne(R)(R source)
if (isInputRange!R)
{
static if (hasSlicing!R)
{
return source[0 .. !source.empty];
}
else
{
static struct Result
{
private R _source;
private bool _empty = true;
@property bool empty() const { return _empty; }
@property auto ref front()
{
assert(!empty, "Attempting to fetch the front of an empty takeOne");
return _source.front;
}
void popFront()
{
assert(!empty, "Attempting to popFront an empty takeOne");
_source.popFront();
_empty = true;
}
void popBack()
{
assert(!empty, "Attempting to popBack an empty takeOne");
_source.popFront();
_empty = true;
}
static if (isForwardRange!(Unqual!R))
{
@property auto save() { return Result(_source.save, empty); }
}
@property auto ref back()
{
assert(!empty, "Attempting to fetch the back of an empty takeOne");
return _source.front;
}
@property size_t length() const { return !empty; }
alias opDollar = length;
auto ref opIndex(size_t n)
{
assert(n < length, "Attempting to index a takeOne out of bounds");
return _source.front;
}
auto opSlice(size_t m, size_t n)
{
assert(
m <= n,
"Attempting to slice a takeOne range with a larger first argument than the second."
);
assert(
n <= length,
"Attempting to slice using an out of bounds index on a takeOne range."
);
return n > m ? this : Result(_source, true);
}
// Non-standard property
@property R source() { return _source; }
}
return Result(source, source.empty);
}
}
///
pure @safe nothrow unittest
{
auto s = takeOne([42, 43, 44]);
static assert(isRandomAccessRange!(typeof(s)));
assert(s.length == 1);
assert(!s.empty);
assert(s.front == 42);
s.front = 43;
assert(s.front == 43);
assert(s.back == 43);
assert(s[0] == 43);
s.popFront();
assert(s.length == 0);
assert(s.empty);
}
pure @safe nothrow @nogc unittest
{
struct NonForwardRange
{
enum empty = false;
int front() { return 42; }
void popFront() {}
}
static assert(!isForwardRange!NonForwardRange);
auto s = takeOne(NonForwardRange());
assert(s.length == 1);
assert(!s.empty);
assert(s.front == 42);
assert(s.back == 42);
assert(s[0] == 42);
auto t = s[0 .. 0];
assert(t.empty);
assert(t.length == 0);
auto u = s[1 .. 1];
assert(u.empty);
assert(u.length == 0);
auto v = s[0 .. 1];
s.popFront();
assert(s.length == 0);
assert(s.empty);
assert(!v.empty);
assert(v.front == 42);
v.popBack();
assert(v.empty);
assert(v.length == 0);
}
pure @safe nothrow @nogc unittest
{
struct NonSlicingForwardRange
{
enum empty = false;
int front() { return 42; }
void popFront() {}
@property auto save() { return this; }
}
static assert(isForwardRange!NonSlicingForwardRange);
static assert(!hasSlicing!NonSlicingForwardRange);
auto s = takeOne(NonSlicingForwardRange());
assert(s.length == 1);
assert(!s.empty);
assert(s.front == 42);
assert(s.back == 42);
assert(s[0] == 42);
auto t = s.save;
s.popFront();
assert(s.length == 0);
assert(s.empty);
assert(!t.empty);
assert(t.front == 42);
t.popBack();
assert(t.empty);
assert(t.length == 0);
}
// Test that asserts trigger correctly
@system unittest
{
import std.exception : assertThrown;
import core.exception : AssertError;
struct NonForwardRange
{
enum empty = false;
int front() { return 42; }
void popFront() {}
}
auto s = takeOne(NonForwardRange());
assertThrown!AssertError(s[1]);
assertThrown!AssertError(s[0 .. 2]);
size_t one = 1; // Avoid style warnings triggered by literals
size_t zero = 0;
assertThrown!AssertError(s[one .. zero]);
s.popFront;
assert(s.empty);
assertThrown!AssertError(s.front);
assertThrown!AssertError(s.back);
assertThrown!AssertError(s.popFront);
assertThrown!AssertError(s.popBack);
}
//guards against issue 16999
pure @safe unittest
{
auto myIota = new class
{
int front = 0;
@safe void popFront(){front++;}
enum empty = false;
};
auto iotaPart = myIota.takeOne;
int sum;
foreach (var; chain(iotaPart, iotaPart, iotaPart))
{
sum += var;
}
assert(sum == 3);
assert(iotaPart.front == 3);
}
/++
Returns an empty range which is statically known to be empty and is
guaranteed to have `length` and be random access regardless of `R`'s
capabilities.
+/
auto takeNone(R)()
if (isInputRange!R)
{
return typeof(takeOne(R.init)).init;
}
///
pure @safe nothrow @nogc unittest
{
auto range = takeNone!(int[])();
assert(range.length == 0);
assert(range.empty);
}
pure @safe nothrow @nogc unittest
{
enum ctfe = takeNone!(int[])();
static assert(ctfe.length == 0);
static assert(ctfe.empty);
}
/++
Creates an empty range from the given range in $(BIGOH 1). If it can, it
will return the same range type. If not, it will return
$(D takeExactly(range, 0)).
+/
auto takeNone(R)(R range)
if (isInputRange!R)
{
import std.traits : isDynamicArray;
//Makes it so that calls to takeNone which don't use UFCS still work with a
//member version if it's defined.
static if (is(typeof(R.takeNone)))
auto retval = range.takeNone();
//@@@BUG@@@ 8339
else static if (isDynamicArray!R)/+ ||
(is(R == struct) && __traits(compiles, {auto r = R.init;}) && R.init.empty))+/
{
auto retval = R.init;
}
//An infinite range sliced at [0 .. 0] would likely still not be empty...
else static if (hasSlicing!R && !isInfinite!R)
auto retval = range[0 .. 0];
else
auto retval = takeExactly(range, 0);
//@@@BUG@@@ 7892 prevents this from being done in an out block.
assert(retval.empty);
return retval;
}
///
pure @safe nothrow unittest
{
import std.algorithm.iteration : filter;
assert(takeNone([42, 27, 19]).empty);
assert(takeNone("dlang.org").empty);
assert(takeNone(filter!"true"([42, 27, 19])).empty);
}
@safe unittest
{
import std.algorithm.iteration : filter;
import std.meta : AliasSeq;
struct Dummy
{
mixin template genInput()
{
@safe:
@property bool empty() { return _arr.empty; }
@property auto front() { return _arr.front; }
void popFront() { _arr.popFront(); }
static assert(isInputRange!(typeof(this)));
}
}
alias genInput = Dummy.genInput;
static struct NormalStruct
{
//Disabled to make sure that the takeExactly version is used.
@disable this();
this(int[] arr) { _arr = arr; }
mixin genInput;
int[] _arr;
}
static struct SliceStruct
{
@disable this();
this(int[] arr) { _arr = arr; }
mixin genInput;
@property auto save() { return this; }
auto opSlice(size_t i, size_t j) { return typeof(this)(_arr[i .. j]); }
@property size_t length() { return _arr.length; }
int[] _arr;
}
static struct InitStruct
{
mixin genInput;
int[] _arr;
}
static struct TakeNoneStruct
{
this(int[] arr) { _arr = arr; }
@disable this();
mixin genInput;
auto takeNone() { return typeof(this)(null); }
int[] _arr;
}
static class NormalClass
{
this(int[] arr) {_arr = arr;}
mixin genInput;
int[] _arr;
}
static class SliceClass
{
@safe:
this(int[] arr) { _arr = arr; }
mixin genInput;
@property auto save() { return new typeof(this)(_arr); }
auto opSlice(size_t i, size_t j) { return new typeof(this)(_arr[i .. j]); }
@property size_t length() { return _arr.length; }
int[] _arr;
}
static class TakeNoneClass
{
@safe:
this(int[] arr) { _arr = arr; }
mixin genInput;
auto takeNone() { return new typeof(this)(null); }
int[] _arr;
}
import std.format : format;
static foreach (range; AliasSeq!([1, 2, 3, 4, 5],
"hello world",
"hello world"w,
"hello world"d,
SliceStruct([1, 2, 3]),
//@@@BUG@@@ 8339 forces this to be takeExactly
//`InitStruct([1, 2, 3]),
TakeNoneStruct([1, 2, 3])))
{
static assert(takeNone(range).empty, typeof(range).stringof);
assert(takeNone(range).empty);
static assert(is(typeof(range) == typeof(takeNone(range))), typeof(range).stringof);
}
static foreach (range; AliasSeq!(NormalStruct([1, 2, 3]),
InitStruct([1, 2, 3])))
{
static assert(takeNone(range).empty, typeof(range).stringof);
assert(takeNone(range).empty);
static assert(is(typeof(takeExactly(range, 0)) == typeof(takeNone(range))), typeof(range).stringof);
}
//Don't work in CTFE.
auto normal = new NormalClass([1, 2, 3]);
assert(takeNone(normal).empty);
static assert(is(typeof(takeExactly(normal, 0)) == typeof(takeNone(normal))), typeof(normal).stringof);
auto slice = new SliceClass([1, 2, 3]);
assert(takeNone(slice).empty);
static assert(is(SliceClass == typeof(takeNone(slice))), typeof(slice).stringof);
auto taken = new TakeNoneClass([1, 2, 3]);
assert(takeNone(taken).empty);
static assert(is(TakeNoneClass == typeof(takeNone(taken))), typeof(taken).stringof);
auto filtered = filter!"true"([1, 2, 3, 4, 5]);
assert(takeNone(filtered).empty);
//@@@BUG@@@ 8339 and 5941 force this to be takeExactly
//static assert(is(typeof(filtered) == typeof(takeNone(filtered))), typeof(filtered).stringof);
}
/++
+ Return a range advanced to within `_n` elements of the end of
+ `range`.
+
+ Intended as the range equivalent of the Unix
+ $(HTTP en.wikipedia.org/wiki/Tail_%28Unix%29, _tail) utility. When the length
+ of `range` is less than or equal to `_n`, `range` is returned
+ as-is.
+
+ Completes in $(BIGOH 1) steps for ranges that support slicing and have
+ length. Completes in $(BIGOH range.length) time for all other ranges.
+
+ Params:
+ range = range to get _tail of
+ n = maximum number of elements to include in _tail
+
+ Returns:
+ Returns the _tail of `range` augmented with length information
+/
auto tail(Range)(Range range, size_t n)
if (isInputRange!Range && !isInfinite!Range &&
(hasLength!Range || isForwardRange!Range))
{
static if (hasLength!Range)
{
immutable length = range.length;
if (n >= length)
return range.takeExactly(length);
else
return range.drop(length - n).takeExactly(n);
}
else
{
Range scout = range.save;
foreach (immutable i; 0 .. n)
{
if (scout.empty)
return range.takeExactly(i);
scout.popFront();
}
auto tail = range.save;
while (!scout.empty)
{
assert(!tail.empty);
scout.popFront();
tail.popFront();
}
return tail.takeExactly(n);
}
}
///
pure @safe nothrow unittest
{
// tail -c n
assert([1, 2, 3].tail(1) == [3]);
assert([1, 2, 3].tail(2) == [2, 3]);
assert([1, 2, 3].tail(3) == [1, 2, 3]);
assert([1, 2, 3].tail(4) == [1, 2, 3]);
assert([1, 2, 3].tail(0).length == 0);
// tail --lines=n
import std.algorithm.comparison : equal;
import std.algorithm.iteration : joiner;
import std.exception : assumeWontThrow;
import std.string : lineSplitter;
assert("one\ntwo\nthree"
.lineSplitter
.tail(2)
.joiner("\n")
.equal("two\nthree")
.assumeWontThrow);
}
// @nogc prevented by @@@BUG@@@ 15408
pure nothrow @safe /+@nogc+/ unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges, DummyRange, Length,
RangeType, ReturnBy;
static immutable cheatsheet = [6, 7, 8, 9, 10];
foreach (R; AllDummyRanges)
{
static if (isInputRange!R && !isInfinite!R &&
(hasLength!R || isForwardRange!R))
{
assert(R.init.tail(5).equal(cheatsheet));
static assert(R.init.tail(5).equal(cheatsheet));
assert(R.init.tail(0).length == 0);
assert(R.init.tail(10).equal(R.init));
assert(R.init.tail(11).equal(R.init));
}
}
// Infinite ranges are not supported
static assert(!__traits(compiles, repeat(0).tail(0)));
// Neither are non-forward ranges without length
static assert(!__traits(compiles, DummyRange!(ReturnBy.Value, Length.No,
RangeType.Input).init.tail(5)));
}
pure @safe nothrow @nogc unittest
{
static immutable input = [1, 2, 3];
static immutable expectedOutput = [2, 3];
assert(input.tail(2) == expectedOutput);
}
/++
Convenience function which calls
$(REF popFrontN, std, range, primitives)`(range, n)` and returns `range`.
`drop` makes it easier to pop elements from a range
and then pass it to another function within a single expression,
whereas `popFrontN` would require multiple statements.
`dropBack` provides the same functionality but instead calls
$(REF popBackN, std, range, primitives)`(range, n)`
Note: `drop` and `dropBack` will only pop $(I up to)
`n` elements but will stop if the range is empty first.
In other languages this is sometimes called `skip`.
Params:
range = the $(REF_ALTTEXT input range, isInputRange, std,range,primitives) to drop from
n = the number of elements to drop
Returns:
`range` with up to `n` elements dropped
See_Also:
$(REF popFront, std, range, primitives), $(REF popBackN, std, range, primitives)
+/
R drop(R)(R range, size_t n)
if (isInputRange!R)
{
range.popFrontN(n);
return range;
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
assert([0, 2, 1, 5, 0, 3].drop(3) == [5, 0, 3]);
assert("hello world".drop(6) == "world");
assert("hello world".drop(50).empty);
assert("hello world".take(6).drop(3).equal("lo "));
}
/// ditto
R dropBack(R)(R range, size_t n)
if (isBidirectionalRange!R)
{
range.popBackN(n);
return range;
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
assert([0, 2, 1, 5, 0, 3].dropBack(3) == [0, 2, 1]);
assert("hello world".dropBack(6) == "hello");
assert("hello world".dropBack(50).empty);
assert("hello world".drop(4).dropBack(4).equal("o w"));
}
@safe unittest
{
import std.algorithm.comparison : equal;
import std.container.dlist : DList;
//Remove all but the first two elements
auto a = DList!int(0, 1, 9, 9, 9, 9);
a.remove(a[].drop(2));
assert(a[].equal(a[].take(2)));
}
@safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filter;
assert(drop("", 5).empty);
assert(equal(drop(filter!"true"([0, 2, 1, 5, 0, 3]), 3), [5, 0, 3]));
}
@safe unittest
{
import std.algorithm.comparison : equal;
import std.container.dlist : DList;
//insert before the last two elements
auto a = DList!int(0, 1, 2, 5, 6);
a.insertAfter(a[].dropBack(2), [3, 4]);
assert(a[].equal(iota(0, 7)));
}
/++
Similar to $(LREF drop) and `dropBack` but they call
$(D range.$(LREF popFrontExactly)(n)) and `range.popBackExactly(n)`
instead.
Note: Unlike `drop`, `dropExactly` will assume that the
range holds at least `n` elements. This makes `dropExactly`
faster than `drop`, but it also means that if `range` does
not contain at least `n` elements, it will attempt to call `popFront`
on an empty range, which is undefined behavior. So, only use
`popFrontExactly` when it is guaranteed that `range` holds at least
`n` elements.
Params:
range = the $(REF_ALTTEXT input range, isInputRange, std,range,primitives) to drop from
n = the number of elements to drop
Returns:
`range` with `n` elements dropped
See_Also:
$(REF popFrontExcatly, std, range, primitives),
$(REF popBackExcatly, std, range, primitives)
+/
R dropExactly(R)(R range, size_t n)
if (isInputRange!R)
{
popFrontExactly(range, n);
return range;
}
/// ditto
R dropBackExactly(R)(R range, size_t n)
if (isBidirectionalRange!R)
{
popBackExactly(range, n);
return range;
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filterBidirectional;
auto a = [1, 2, 3];
assert(a.dropExactly(2) == [3]);
assert(a.dropBackExactly(2) == [1]);
string s = "日本語";
assert(s.dropExactly(2) == "語");
assert(s.dropBackExactly(2) == "日");
auto bd = filterBidirectional!"true"([1, 2, 3]);
assert(bd.dropExactly(2).equal([3]));
assert(bd.dropBackExactly(2).equal([1]));
}
/++
Convenience function which calls
`range.popFront()` and returns `range`. `dropOne`
makes it easier to pop an element from a range
and then pass it to another function within a single expression,
whereas `popFront` would require multiple statements.
`dropBackOne` provides the same functionality but instead calls
`range.popBack()`.
+/
R dropOne(R)(R range)
if (isInputRange!R)
{
range.popFront();
return range;
}
/// ditto
R dropBackOne(R)(R range)
if (isBidirectionalRange!R)
{
range.popBack();
return range;
}
///
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filterBidirectional;
import std.container.dlist : DList;
auto dl = DList!int(9, 1, 2, 3, 9);
assert(dl[].dropOne().dropBackOne().equal([1, 2, 3]));
auto a = [1, 2, 3];
assert(a.dropOne() == [2, 3]);
assert(a.dropBackOne() == [1, 2]);
string s = "日本語";
import std.exception : assumeWontThrow;
assert(assumeWontThrow(s.dropOne() == "本語"));
assert(assumeWontThrow(s.dropBackOne() == "日本"));
auto bd = filterBidirectional!"true"([1, 2, 3]);
assert(bd.dropOne().equal([2, 3]));
assert(bd.dropBackOne().equal([1, 2]));
}
/**
Create a range which repeats one value.
Params:
value = the _value to repeat
n = the number of times to repeat `value`
Returns:
If `n` is not defined, an infinite random access range
with slicing.
If `n` is defined, a random access range with slicing.
*/
struct Repeat(T)
{
private:
//Store a non-qualified T when possible: This is to make Repeat assignable
static if ((is(T == class) || is(T == interface)) && (is(T == const) || is(T == immutable)))
{
import std.typecons : Rebindable;
alias UT = Rebindable!T;
}
else static if (is(T : Unqual!T) && is(Unqual!T : T))
alias UT = Unqual!T;
else
alias UT = T;
UT _value;
public:
/// Range primitives
@property inout(T) front() inout { return _value; }
/// ditto
@property inout(T) back() inout { return _value; }
/// ditto
enum bool empty = false;
/// ditto
void popFront() {}
/// ditto
void popBack() {}
/// ditto
@property auto save() inout { return this; }
/// ditto
inout(T) opIndex(size_t) inout { return _value; }
/// ditto
auto opSlice(size_t i, size_t j)
in
{
assert(
i <= j,
"Attempting to slice a Repeat with a larger first argument than the second."
);
}
do
{
return this.takeExactly(j - i);
}
private static struct DollarToken {}
/// ditto
enum opDollar = DollarToken.init;
/// ditto
auto opSlice(size_t, DollarToken) inout { return this; }
}
/// Ditto
Repeat!T repeat(T)(T value) { return Repeat!T(value); }
///
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
assert(5.repeat().take(4).equal([5, 5, 5, 5]));
}
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
auto r = repeat(5);
alias R = typeof(r);
static assert(isBidirectionalRange!R);
static assert(isForwardRange!R);
static assert(isInfinite!R);
static assert(hasSlicing!R);
assert(r.back == 5);
assert(r.front == 5);
assert(r.take(4).equal([ 5, 5, 5, 5 ]));
assert(r[0 .. 4].equal([ 5, 5, 5, 5 ]));
R r2 = r[5 .. $];
assert(r2.back == 5);
assert(r2.front == 5);
}
/// ditto
Take!(Repeat!T) repeat(T)(T value, size_t n)
{
return take(repeat(value), n);
}
///
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
assert(5.repeat(4).equal([5, 5, 5, 5]));
}
pure @safe nothrow unittest //12007
{
static class C{}
Repeat!(immutable int) ri;
ri = ri.save;
Repeat!(immutable C) rc;
rc = rc.save;
import std.algorithm.setops : cartesianProduct;
import std.algorithm.comparison : equal;
import std.typecons : tuple;
immutable int[] A = [1,2,3];
immutable int[] B = [4,5,6];
assert(equal(cartesianProduct(A,B),
[
tuple(1, 4), tuple(1, 5), tuple(1, 6),
tuple(2, 4), tuple(2, 5), tuple(2, 6),
tuple(3, 4), tuple(3, 5), tuple(3, 6),
]));
}
/**
Given callable ($(REF isCallable, std,traits)) `fun`, create as a range
whose front is defined by successive calls to `fun()`.
This is especially useful to call function with global side effects (random
functions), or to create ranges expressed as a single delegate, rather than
an entire `front`/`popFront`/`empty` structure.
`fun` maybe be passed either a template alias parameter (existing
function, delegate, struct type defining `static opCall`) or
a run-time value argument (delegate, function object).
The result range models an InputRange
($(REF isInputRange, std,range,primitives)).
The resulting range will call `fun()` on construction, and every call to
`popFront`, and the cached value will be returned when `front` is called.
Returns: an `inputRange` where each element represents another call to fun.
*/
auto generate(Fun)(Fun fun)
if (isCallable!fun)
{
auto gen = Generator!(Fun)(fun);
gen.popFront(); // prime the first element
return gen;
}
/// ditto
auto generate(alias fun)()
if (isCallable!fun)
{
auto gen = Generator!(fun)();
gen.popFront(); // prime the first element
return gen;
}
///
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : map;
int i = 1;
auto powersOfTwo = generate!(() => i *= 2)().take(10);
assert(equal(powersOfTwo, iota(1, 11).map!"2^^a"()));
}
///
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
//Returns a run-time delegate
auto infiniteIota(T)(T low, T high)
{
T i = high;
return (){if (i == high) i = low; return i++;};
}
//adapted as a range.
assert(equal(generate(infiniteIota(1, 4)).take(10), [1, 2, 3, 1, 2, 3, 1, 2, 3, 1]));
}
///
@safe unittest
{
import std.format : format;
import std.random : uniform;
auto r = generate!(() => uniform(0, 6)).take(10);
format("%(%s %)", r);
}
private struct Generator(Fun...)
{
static assert(Fun.length == 1);
static assert(isInputRange!Generator);
import std.traits : FunctionAttribute, functionAttributes, ReturnType;
private:
static if (is(Fun[0]))
Fun[0] fun;
else
alias fun = Fun[0];
enum returnByRef_ = (functionAttributes!fun & FunctionAttribute.ref_) ? true : false;
static if (returnByRef_)
ReturnType!fun *elem_;
else
ReturnType!fun elem_;
public:
/// Range primitives
enum empty = false;
static if (returnByRef_)
{
/// ditto
ref front() @property
{
return *elem_;
}
/// ditto
void popFront()
{
elem_ = &fun();
}
}
else
{
/// ditto
auto front() @property
{
return elem_;
}
/// ditto
void popFront()
{
elem_ = fun();
}
}
}
@safe nothrow unittest
{
import std.algorithm.comparison : equal;
struct StaticOpCall
{
static ubyte opCall() { return 5 ; }
}
assert(equal(generate!StaticOpCall().take(10), repeat(5).take(10)));
}
@safe pure unittest
{
import std.algorithm.comparison : equal;
struct OpCall
{
ubyte opCall() @safe pure { return 5 ; }
}
OpCall op;
assert(equal(generate(op).take(10), repeat(5).take(10)));
}
// verify ref mechanism works
@system nothrow unittest
{
int[10] arr;
int idx;
ref int fun() {
auto x = idx++;
idx %= arr.length;
return arr[x];
}
int y = 1;
foreach (ref x; generate!(fun).take(20))
{
x += y++;
}
import std.algorithm.comparison : equal;
assert(equal(arr[], iota(12, 32, 2)));
}
// assure front isn't the mechanism to make generate go to the next element.
@safe unittest
{
int i;
auto g = generate!(() => ++i);
auto f = g.front;
assert(f == g.front);
g = g.drop(5); // reassign because generate caches
assert(g.front == f + 5);
}
/**
Repeats the given forward range ad infinitum. If the original range is
infinite (fact that would make `Cycle` the identity application),
`Cycle` detects that and aliases itself to the range type
itself. That works for non-forward ranges too.
If the original range has random access, `Cycle` offers
random access and also offers a constructor taking an initial position
`index`. `Cycle` works with static arrays in addition to ranges,
mostly for performance reasons.
Note: The input range must not be empty.
Tip: This is a great way to implement simple circular buffers.
*/
struct Cycle(R)
if (isForwardRange!R && !isInfinite!R)
{
static if (isRandomAccessRange!R && hasLength!R)
{
private R _original;
private size_t _index;
/// Range primitives
this(R input, size_t index = 0)
{
_original = input;
_index = index % _original.length;
}
/// ditto
@property auto ref front()
{
return _original[_index];
}
static if (is(typeof((cast(const R)_original)[_index])))
{
/// ditto
@property auto ref front() const
{
return _original[_index];
}
}
static if (hasAssignableElements!R)
{
/// ditto
@property void front(ElementType!R val)
{
_original[_index] = val;
}
}
/// ditto
enum bool empty = false;
/// ditto
void popFront()
{
++_index;
if (_index >= _original.length)
_index = 0;
}
/// ditto
auto ref opIndex(size_t n)
{
return _original[(n + _index) % _original.length];
}
static if (is(typeof((cast(const R)_original)[_index])) &&
is(typeof((cast(const R)_original).length)))
{
/// ditto
auto ref opIndex(size_t n) const
{
return _original[(n + _index) % _original.length];
}
}
static if (hasAssignableElements!R)
{
/// ditto
void opIndexAssign(ElementType!R val, size_t n)
{
_original[(n + _index) % _original.length] = val;
}
}
/// ditto
@property Cycle save()
{
//No need to call _original.save, because Cycle never actually modifies _original
return Cycle(_original, _index);
}
private static struct DollarToken {}
/// ditto
enum opDollar = DollarToken.init;
static if (hasSlicing!R)
{
/// ditto
auto opSlice(size_t i, size_t j)
in
{
assert(i <= j);
}
do
{
return this[i .. $].takeExactly(j - i);
}
/// ditto
auto opSlice(size_t i, DollarToken)
{
return typeof(this)(_original, _index + i);
}
}
}
else
{
private R _original;
private R _current;
/// ditto
this(R input)
{
_original = input;
_current = input.save;
}
private this(R original, R current)
{
_original = original;
_current = current;
}
/// ditto
@property auto ref front()
{
return _current.front;
}
static if (is(typeof((cast(const R)_current).front)))
{
/// ditto
@property auto ref front() const
{
return _current.front;
}
}
static if (hasAssignableElements!R)
{
/// ditto
@property auto front(ElementType!R val)
{
return _current.front = val;
}
}
/// ditto
enum bool empty = false;
/// ditto
void popFront()
{
_current.popFront();
if (_current.empty)
_current = _original.save;
}
/// ditto
@property Cycle save()
{
//No need to call _original.save, because Cycle never actually modifies _original
return Cycle(_original, _current.save);
}
}
}
/// ditto
template Cycle(R)
if (isInfinite!R)
{
alias Cycle = R;
}
/// ditto
struct Cycle(R)
if (isStaticArray!R)
{
private alias ElementType = typeof(R.init[0]);
private ElementType* _ptr;
private size_t _index;
nothrow:
/// Range primitives
this(ref R input, size_t index = 0) @system
{
_ptr = input.ptr;
_index = index % R.length;
}
/// ditto
@property ref inout(ElementType) front() inout @safe
{
static ref auto trustedPtrIdx(typeof(_ptr) p, size_t idx) @trusted
{
return p[idx];
}
return trustedPtrIdx(_ptr, _index);
}
/// ditto
enum bool empty = false;
/// ditto
void popFront() @safe
{
++_index;
if (_index >= R.length)
_index = 0;
}
/// ditto
ref inout(ElementType) opIndex(size_t n) inout @safe
{
static ref auto trustedPtrIdx(typeof(_ptr) p, size_t idx) @trusted
{
return p[idx % R.length];
}
return trustedPtrIdx(_ptr, n + _index);
}
/// ditto
@property inout(Cycle) save() inout @safe
{
return this;
}
private static struct DollarToken {}
/// ditto
enum opDollar = DollarToken.init;
/// ditto
auto opSlice(size_t i, size_t j) @safe
in
{
assert(
i <= j,
"Attempting to slice a Repeat with a larger first argument than the second."
);
}
do
{
return this[i .. $].takeExactly(j - i);
}
/// ditto
inout(typeof(this)) opSlice(size_t i, DollarToken) inout @safe
{
static auto trustedCtor(typeof(_ptr) p, size_t idx) @trusted
{
return cast(inout) Cycle(*cast(R*)(p), idx);
}
return trustedCtor(_ptr, _index + i);
}
}
/// Ditto
auto cycle(R)(R input)
if (isInputRange!R)
{
static assert(isForwardRange!R || isInfinite!R,
"Cycle requires a forward range argument unless it's statically known"
~ " to be infinite");
assert(!input.empty, "Attempting to pass an empty input to cycle");
static if (isInfinite!R) return input;
else return Cycle!R(input);
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
import std.range : cycle, take;
// Here we create an infinitive cyclic sequence from [1, 2]
// (i.e. get here [1, 2, 1, 2, 1, 2 and so on]) then
// take 5 elements of this sequence (so we have [1, 2, 1, 2, 1])
// and compare them with the expected values for equality.
assert(cycle([1, 2]).take(5).equal([ 1, 2, 1, 2, 1 ]));
}
/// Ditto
Cycle!R cycle(R)(R input, size_t index = 0)
if (isRandomAccessRange!R && !isInfinite!R)
{
assert(!input.empty, "Attempting to pass an empty input to cycle");
return Cycle!R(input, index);
}
/// Ditto
Cycle!R cycle(R)(ref R input, size_t index = 0) @system
if (isStaticArray!R)
{
return Cycle!R(input, index);
}
@safe nothrow unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges;
static assert(isForwardRange!(Cycle!(uint[])));
// Make sure ref is getting propagated properly.
int[] nums = [1,2,3];
auto c2 = cycle(nums);
c2[3]++;
assert(nums[0] == 2);
immutable int[] immarr = [1, 2, 3];
foreach (DummyType; AllDummyRanges)
{
static if (isForwardRange!DummyType)
{
DummyType dummy;
auto cy = cycle(dummy);
static assert(isForwardRange!(typeof(cy)));
auto t = take(cy, 20);
assert(equal(t, [1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10]));
const cRange = cy;
assert(cRange.front == 1);
static if (hasAssignableElements!DummyType)
{
{
cy.front = 66;
scope(exit) cy.front = 1;
assert(dummy.front == 66);
}
static if (isRandomAccessRange!DummyType)
{
{
cy[10] = 66;
scope(exit) cy[10] = 1;
assert(dummy.front == 66);
}
assert(cRange[10] == 1);
}
}
static if (hasSlicing!DummyType)
{
auto slice = cy[5 .. 15];
assert(equal(slice, [6, 7, 8, 9, 10, 1, 2, 3, 4, 5]));
static assert(is(typeof(slice) == typeof(takeExactly(cy, 5))));
auto infSlice = cy[7 .. $];
assert(equal(take(infSlice, 5), [8, 9, 10, 1, 2]));
static assert(isInfinite!(typeof(infSlice)));
}
}
}
}
@system nothrow unittest // For static arrays.
{
import std.algorithm.comparison : equal;
int[3] a = [ 1, 2, 3 ];
static assert(isStaticArray!(typeof(a)));
auto c = cycle(a);
assert(a.ptr == c._ptr);
assert(equal(take(cycle(a), 5), [ 1, 2, 3, 1, 2 ][]));
static assert(isForwardRange!(typeof(c)));
// Test qualifiers on slicing.
alias C = typeof(c);
static assert(is(typeof(c[1 .. $]) == C));
const cConst = c;
static assert(is(typeof(cConst[1 .. $]) == const(C)));
}
@safe nothrow unittest // For infinite ranges
{
struct InfRange
{
void popFront() { }
@property int front() { return 0; }
enum empty = false;
auto save() { return this; }
}
struct NonForwardInfRange
{
void popFront() { }
@property int front() { return 0; }
enum empty = false;
}
InfRange i;
NonForwardInfRange j;
auto c = cycle(i);
assert(c == i);
//make sure it can alias out even non-forward infinite ranges
static assert(is(typeof(j.cycle) == typeof(j)));
}
@safe unittest
{
import std.algorithm.comparison : equal;
int[5] arr = [0, 1, 2, 3, 4];
auto cleD = cycle(arr[]); //Dynamic
assert(equal(cleD[5 .. 10], arr[]));
//n is a multiple of 5 worth about 3/4 of size_t.max
auto n = size_t.max/4 + size_t.max/2;
n -= n % 5;
//Test index overflow
foreach (_ ; 0 .. 10)
{
cleD = cleD[n .. $];
assert(equal(cleD[5 .. 10], arr[]));
}
}
@system @nogc nothrow unittest
{
import std.algorithm.comparison : equal;
int[5] arr = [0, 1, 2, 3, 4];
auto cleS = cycle(arr); //Static
assert(equal(cleS[5 .. 10], arr[]));
//n is a multiple of 5 worth about 3/4 of size_t.max
auto n = size_t.max/4 + size_t.max/2;
n -= n % 5;
//Test index overflow
foreach (_ ; 0 .. 10)
{
cleS = cleS[n .. $];
assert(equal(cleS[5 .. 10], arr[]));
}
}
@system unittest
{
import std.algorithm.comparison : equal;
int[1] arr = [0];
auto cleS = cycle(arr);
cleS = cleS[10 .. $];
assert(equal(cleS[5 .. 10], 0.repeat(5)));
assert(cleS.front == 0);
}
@system unittest //10845
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filter;
auto a = inputRangeObject(iota(3).filter!"true");
assert(equal(cycle(a).take(10), [0, 1, 2, 0, 1, 2, 0, 1, 2, 0]));
}
@safe unittest // 12177
{
static assert(__traits(compiles, recurrence!q{a[n - 1] ~ a[n - 2]}("1", "0")));
}
// Issue 13390
@system unittest
{
import core.exception : AssertError;
import std.exception : assertThrown;
assertThrown!AssertError(cycle([0, 1, 2][0 .. 0]));
}
pure @safe unittest // issue 18657
{
import std.algorithm.comparison : equal;
string s = "foo";
auto r = refRange(&s).cycle.take(4);
assert(equal(r.save, "foof"));
assert(equal(r.save, "foof"));
}
private alias lengthType(R) = typeof(R.init.length.init);
/**
Iterate several ranges in lockstep. The element type is a proxy tuple
that allows accessing the current element in the `n`th range by
using `e[n]`.
`zip` is similar to $(LREF lockstep), but `lockstep` doesn't
bundle its elements and uses the `opApply` protocol.
`lockstep` allows reference access to the elements in
`foreach` iterations.
Params:
sp = controls what `zip` will do if the ranges are different lengths
ranges = the ranges to zip together
Returns:
At minimum, an input range. `Zip` offers the lowest range facilities
of all components, e.g. it offers random access iff all ranges offer
random access, and also offers mutation and swapping if all ranges offer
it. Due to this, `Zip` is extremely powerful because it allows manipulating
several ranges in lockstep.
Throws:
An `Exception` if all of the ranges are not the same length and
`sp` is set to `StoppingPolicy.requireSameLength`.
Limitations: The `@nogc` and `nothrow` attributes cannot be inferred for
the `Zip` struct because $(LREF StoppingPolicy) can vary at runtime. This
limitation is not shared by the anonymous range returned by the `zip`
function when not given an explicit `StoppingPolicy` as an argument.
*/
struct Zip(Ranges...)
if (Ranges.length && allSatisfy!(isInputRange, Ranges))
{
import std.format : format; //for generic mixins
import std.typecons : Tuple;
alias R = Ranges;
private R ranges;
alias ElementType = Tuple!(staticMap!(.ElementType, R));
private StoppingPolicy stoppingPolicy = StoppingPolicy.shortest;
/**
Builds an object. Usually this is invoked indirectly by using the
$(LREF zip) function.
*/
this(R rs, StoppingPolicy s = StoppingPolicy.shortest)
{
ranges[] = rs[];
stoppingPolicy = s;
}
/**
Returns `true` if the range is at end. The test depends on the
stopping policy.
*/
static if (allSatisfy!(isInfinite, R))
{
// BUG: Doesn't propagate infiniteness if only some ranges are infinite
// and s == StoppingPolicy.longest. This isn't fixable in the
// current design since StoppingPolicy is known only at runtime.
enum bool empty = false;
}
else
{
///
@property bool empty()
{
import std.exception : enforce;
import std.meta : anySatisfy;
final switch (stoppingPolicy)
{
case StoppingPolicy.shortest:
foreach (i, Unused; R)
{
if (ranges[i].empty) return true;
}
return false;
case StoppingPolicy.longest:
static if (anySatisfy!(isInfinite, R))
{
return false;
}
else
{
foreach (i, Unused; R)
{
if (!ranges[i].empty) return false;
}
return true;
}
case StoppingPolicy.requireSameLength:
foreach (i, Unused; R[1 .. $])
{
enforce(ranges[0].empty ==
ranges[i + 1].empty,
"Inequal-length ranges passed to Zip");
}
return ranges[0].empty;
}
assert(false);
}
}
static if (allSatisfy!(isForwardRange, R))
{
///
@property Zip save()
{
//Zip(ranges[0].save, ranges[1].save, ..., stoppingPolicy)
return mixin (q{Zip(%(ranges[%s].save%|, %), stoppingPolicy)}.format(iota(0, R.length)));
}
}
private .ElementType!(R[i]) tryGetInit(size_t i)()
{
alias E = .ElementType!(R[i]);
static if (!is(typeof({static E i;})))
throw new Exception("Range with non-default constructable elements exhausted.");
else
return E.init;
}
/**
Returns the current iterated element.
*/
@property ElementType front()
{
@property tryGetFront(size_t i)(){return ranges[i].empty ? tryGetInit!i() : ranges[i].front;}
//ElementType(tryGetFront!0, tryGetFront!1, ...)
return mixin(q{ElementType(%(tryGetFront!%s, %))}.format(iota(0, R.length)));
}
/**
Sets the front of all iterated ranges.
*/
static if (allSatisfy!(hasAssignableElements, R))
{
@property void front(ElementType v)
{
foreach (i, Unused; R)
{
if (!ranges[i].empty)
{
ranges[i].front = v[i];
}
}
}
}
/**
Moves out the front.
*/
static if (allSatisfy!(hasMobileElements, R))
{
ElementType moveFront()
{
@property tryMoveFront(size_t i)(){return ranges[i].empty ? tryGetInit!i() : ranges[i].moveFront();}
//ElementType(tryMoveFront!0, tryMoveFront!1, ...)
return mixin(q{ElementType(%(tryMoveFront!%s, %))}.format(iota(0, R.length)));
}
}
/**
Returns the rightmost element.
*/
static if (allSatisfy!(isBidirectionalRange, R))
{
@property ElementType back()
{
//TODO: Fixme! BackElement != back of all ranges in case of jagged-ness
@property tryGetBack(size_t i)(){return ranges[i].empty ? tryGetInit!i() : ranges[i].back;}
//ElementType(tryGetBack!0, tryGetBack!1, ...)
return mixin(q{ElementType(%(tryGetBack!%s, %))}.format(iota(0, R.length)));
}
/**
Moves out the back.
*/
static if (allSatisfy!(hasMobileElements, R))
{
ElementType moveBack()
{
//TODO: Fixme! BackElement != back of all ranges in case of jagged-ness
@property tryMoveBack(size_t i)(){return ranges[i].empty ? tryGetInit!i() : ranges[i].moveBack();}
//ElementType(tryMoveBack!0, tryMoveBack!1, ...)
return mixin(q{ElementType(%(tryMoveBack!%s, %))}.format(iota(0, R.length)));
}
}
/**
Returns the current iterated element.
*/
static if (allSatisfy!(hasAssignableElements, R))
{
@property void back(ElementType v)
{
//TODO: Fixme! BackElement != back of all ranges in case of jagged-ness.
//Not sure the call is even legal for StoppingPolicy.longest
foreach (i, Unused; R)
{
if (!ranges[i].empty)
{
ranges[i].back = v[i];
}
}
}
}
}
/**
Advances to the next element in all controlled ranges.
*/
void popFront()
{
import std.exception : enforce;
final switch (stoppingPolicy)
{
case StoppingPolicy.shortest:
foreach (i, Unused; R)
{
assert(!ranges[i].empty);
ranges[i].popFront();
}
break;
case StoppingPolicy.longest:
foreach (i, Unused; R)
{
if (!ranges[i].empty) ranges[i].popFront();
}
break;
case StoppingPolicy.requireSameLength:
foreach (i, Unused; R)
{
enforce(!ranges[i].empty, "Invalid Zip object");
ranges[i].popFront();
}
break;
}
}
/**
Calls `popBack` for all controlled ranges.
*/
static if (allSatisfy!(isBidirectionalRange, R))
{
void popBack()
{
//TODO: Fixme! In case of jaggedness, this is wrong.
import std.exception : enforce;
final switch (stoppingPolicy)
{
case StoppingPolicy.shortest:
foreach (i, Unused; R)
{
assert(!ranges[i].empty);
ranges[i].popBack();
}
break;
case StoppingPolicy.longest:
foreach (i, Unused; R)
{
if (!ranges[i].empty) ranges[i].popBack();
}
break;
case StoppingPolicy.requireSameLength:
foreach (i, Unused; R)
{
enforce(!ranges[i].empty, "Invalid Zip object");
ranges[i].popBack();
}
break;
}
}
}
/**
Returns the length of this range. Defined only if all ranges define
`length`.
*/
static if (allSatisfy!(hasLength, R))
{
@property auto length()
{
static if (Ranges.length == 1)
return ranges[0].length;
else
{
if (stoppingPolicy == StoppingPolicy.requireSameLength)
return ranges[0].length;
//[min|max](ranges[0].length, ranges[1].length, ...)
import std.algorithm.comparison : min, max;
if (stoppingPolicy == StoppingPolicy.shortest)
return mixin(q{min(%(ranges[%s].length%|, %))}.format(iota(0, R.length)));
else
return mixin(q{max(%(ranges[%s].length%|, %))}.format(iota(0, R.length)));
}
}
alias opDollar = length;
}
/**
Returns a slice of the range. Defined only if all range define
slicing.
*/
static if (allSatisfy!(hasSlicing, R))
{
auto opSlice(size_t from, size_t to)
{
//Slicing an infinite range yields the type Take!R
//For finite ranges, the type Take!R aliases to R
alias ZipResult = Zip!(staticMap!(Take, R));
//ZipResult(ranges[0][from .. to], ranges[1][from .. to], ..., stoppingPolicy)
return mixin (q{ZipResult(%(ranges[%s][from .. to]%|, %), stoppingPolicy)}.format(iota(0, R.length)));
}
}
/**
Returns the `n`th element in the composite range. Defined if all
ranges offer random access.
*/
static if (allSatisfy!(isRandomAccessRange, R))
{
ElementType opIndex(size_t n)
{
//TODO: Fixme! This may create an out of bounds access
//for StoppingPolicy.longest
//ElementType(ranges[0][n], ranges[1][n], ...)
return mixin (q{ElementType(%(ranges[%s][n]%|, %))}.format(iota(0, R.length)));
}
/**
Assigns to the `n`th element in the composite range. Defined if
all ranges offer random access.
*/
static if (allSatisfy!(hasAssignableElements, R))
{
void opIndexAssign(ElementType v, size_t n)
{
//TODO: Fixme! Not sure the call is even legal for StoppingPolicy.longest
foreach (i, Range; R)
{
ranges[i][n] = v[i];
}
}
}
/**
Destructively reads the `n`th element in the composite
range. Defined if all ranges offer random access.
*/
static if (allSatisfy!(hasMobileElements, R))
{
ElementType moveAt(size_t n)
{
//TODO: Fixme! This may create an out of bounds access
//for StoppingPolicy.longest
//ElementType(ranges[0].moveAt(n), ranges[1].moveAt(n), ..., )
return mixin (q{ElementType(%(ranges[%s].moveAt(n)%|, %))}.format(iota(0, R.length)));
}
}
}
}
/// Ditto
auto zip(Ranges...)(Ranges ranges)
if (Ranges.length && allSatisfy!(isInputRange, Ranges))
{
import std.meta : anySatisfy, templateOr;
static if (allSatisfy!(isInfinite, Ranges) || Ranges.length == 1)
{
return ZipShortest!(Ranges)(ranges);
}
else static if (allSatisfy!(isBidirectionalRange, Ranges))
{
static if (allSatisfy!(templateOr!(isInfinite, hasLength), Ranges)
&& allSatisfy!(templateOr!(isInfinite, hasSlicing), Ranges)
&& allSatisfy!(isBidirectionalRange, staticMap!(Take, Ranges)))
{
// If all the ranges are bidirectional, if possible slice them to
// the same length to simplify the implementation.
static assert(anySatisfy!(hasLength, Ranges));
static foreach (i, Range; Ranges)
static if (hasLength!Range)
{
static if (!anySatisfy!(hasLength, Ranges[0 .. i]))
size_t minLen = ranges[i].length;
else
{{
const x = ranges[i].length;
if (x < minLen) minLen = x;
}}
}
import std.format : format;
static if (!anySatisfy!(isInfinite, Ranges))
return mixin(`ZipShortest!(Yes.allKnownSameLength, staticMap!(Take, Ranges))`~
`(%(ranges[%s][0 .. minLen]%|, %))`.format(iota(0, Ranges.length)));
else
return mixin(`ZipShortest!(Yes.allKnownSameLength, staticMap!(Take, Ranges))`~
`(%(take(ranges[%s], minLen)%|, %))`.format(iota(0, Ranges.length)));
}
else static if (allSatisfy!(isRandomAccessRange, Ranges))
{
// We can't slice but we can still use random access to ensure
// "back" is retrieving the same index for each range.
return ZipShortest!(Ranges)(ranges);
}
else
{
// If bidirectional range operations would not be supported by
// ZipShortest that might have actually been a bug since Zip
// supported `back` without verifying that each range had the
// same length, but for the sake of backwards compatibility
// use the old Zip to continue supporting them.
return Zip!Ranges(ranges);
}
}
else
{
return ZipShortest!(Ranges)(ranges);
}
}
///
@nogc nothrow pure @safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : map;
// pairwise sum
auto arr = only(0, 1, 2);
auto part1 = zip(arr, arr.dropOne).map!"a[0] + a[1]";
assert(part1.equal(only(1, 3)));
}
///
nothrow pure @safe unittest
{
import std.conv : to;
int[] a = [ 1, 2, 3 ];
string[] b = [ "a", "b", "c" ];
string[] result;
foreach (tup; zip(a, b))
{
result ~= tup[0].to!string ~ tup[1];
}
assert(result == [ "1a", "2b", "3c" ]);
size_t idx = 0;
// unpacking tuple elements with foreach
foreach (e1, e2; zip(a, b))
{
assert(e1 == a[idx]);
assert(e2 == b[idx]);
++idx;
}
}
/// `zip` is powerful - the following code sorts two arrays in parallel:
nothrow pure @safe unittest
{
import std.algorithm.sorting : sort;
int[] a = [ 1, 2, 3 ];
string[] b = [ "a", "c", "b" ];
zip(a, b).sort!((t1, t2) => t1[0] > t2[0]);
assert(a == [ 3, 2, 1 ]);
// b is sorted according to a's sorting
assert(b == [ "b", "c", "a" ]);
}
/// Ditto
auto zip(Ranges...)(StoppingPolicy sp, Ranges ranges)
if (Ranges.length && allSatisfy!(isInputRange, Ranges))
{
return Zip!Ranges(ranges, sp);
}
/**
Dictates how iteration in a $(LREF zip) and $(LREF lockstep) should stop.
By default stop at the end of the shortest of all ranges.
*/
enum StoppingPolicy
{
/// Stop when the shortest range is exhausted
shortest,
/// Stop when the longest range is exhausted
longest,
/// Require that all ranges are equal
requireSameLength,
}
///
pure @safe unittest
{
import std.algorithm.comparison : equal;
import std.exception : assertThrown;
import std.range.primitives;
import std.typecons : tuple;
auto a = [1, 2, 3];
auto b = [4, 5, 6, 7];
auto shortest = zip(StoppingPolicy.shortest, a, b);
assert(shortest.equal([
tuple(1, 4),
tuple(2, 5),
tuple(3, 6)
]));
auto longest = zip(StoppingPolicy.longest, a, b);
assert(longest.equal([
tuple(1, 4),
tuple(2, 5),
tuple(3, 6),
tuple(0, 7)
]));
auto same = zip(StoppingPolicy.requireSameLength, a, b);
same.popFrontN(3);
assertThrown!Exception(same.popFront);
}
/+
Non-public. Like $(LREF Zip) with `StoppingPolicy.shortest`
except it properly implements `back` and `popBack` in the
case of uneven ranges or disables those operations when
it is not possible to guarantee they are correct.
+/
package template ZipShortest(Ranges...)
if (Ranges.length && __traits(compiles,
{
static assert(allSatisfy!(isInputRange, Ranges));
}))
{
alias ZipShortest = .ZipShortest!(
Ranges.length == 1 || allSatisfy!(isInfinite, Ranges)
? Yes.allKnownSameLength
: No.allKnownSameLength,
Ranges);
}
/+ non-public, ditto +/
package struct ZipShortest(Flag!"allKnownSameLength" allKnownSameLength, Ranges...)
if (Ranges.length && allSatisfy!(isInputRange, Ranges))
{
import std.format : format; //for generic mixins
import std.meta : anySatisfy, templateOr;
import std.typecons : Tuple;
deprecated("Use of an undocumented alias R.")
alias R = Ranges; // Unused here but defined in case library users rely on it.
private Ranges ranges;
alias ElementType = Tuple!(staticMap!(.ElementType, Ranges));
/+
Builds an object. Usually this is invoked indirectly by using the
$(LREF zip) function.
+/
this(Ranges rs)
{
ranges[] = rs[];
}
/+
Returns `true` if the range is at end.
+/
static if (allKnownSameLength ? anySatisfy!(isInfinite, Ranges)
: allSatisfy!(isInfinite, Ranges))
{
enum bool empty = false;
}
else
{
@property bool empty()
{
static if (allKnownSameLength)
{
return ranges[0].empty;
}
else
{
static foreach (i; 0 .. Ranges.length)
{
if (ranges[i].empty)
return true;
}
return false;
}
}
}
/+
Forward range primitive. Only present if each constituent range is a
forward range.
+/
static if (allSatisfy!(isForwardRange, Ranges))
@property typeof(this) save()
{
return mixin(`typeof(return)(%(ranges[%s].save%|, %))`.format(iota(0, Ranges.length)));
}
/+
Returns the current iterated element.
+/
@property ElementType front()
{
return mixin(`typeof(return)(%(ranges[%s].front%|, %))`.format(iota(0, Ranges.length)));
}
/+
Sets the front of all iterated ranges. Only present if each constituent
range has assignable elements.
+/
static if (allSatisfy!(hasAssignableElements, Ranges))
@property void front()(ElementType v)
{
static foreach (i; 0 .. Ranges.length)
ranges[i].front = v[i];
}
/+
Moves out the front. Present if each constituent range has mobile elements.
+/
static if (allSatisfy!(hasMobileElements, Ranges))
ElementType moveFront()()
{
return mixin(`typeof(return)(%(ranges[%s].moveFront()%|, %))`.format(iota(0, Ranges.length)));
}
private enum bool isBackWellDefined = allSatisfy!(isBidirectionalRange, Ranges)
&& (allKnownSameLength
|| allSatisfy!(isRandomAccessRange, Ranges)
// Could also add the case where there is one non-infinite bidirectional
// range that defines `length` and all others are infinite random access
// ranges. Adding this would require appropriate branches in
// back/moveBack/popBack.
);
/+
Returns the rightmost element. Present if all constituent ranges are
bidirectional and either there is a compile-time guarantee that all
ranges have the same length (in `allKnownSameLength`) or all ranges
provide random access to elements.
+/
static if (isBackWellDefined)
@property ElementType back()
{
static if (allKnownSameLength)
{
return mixin(`typeof(return)(%(ranges[%s].back()%|, %))`.format(iota(0, Ranges.length)));
}
else
{
const backIndex = length - 1;
return mixin(`typeof(return)(%(ranges[%s][backIndex]%|, %))`.format(iota(0, Ranges.length)));
}
}
/+
Moves out the back. Present if `back` is defined and
each constituent range has mobile elements.
+/
static if (isBackWellDefined && allSatisfy!(hasMobileElements, Ranges))
ElementType moveBack()()
{
static if (allKnownSameLength)
{
return mixin(`typeof(return)(%(ranges[%s].moveBack()%|, %))`.format(iota(0, Ranges.length)));
}
else
{
const backIndex = length - 1;
return mixin(`typeof(return)(%(ranges[%s].moveAt(backIndex)%|, %))`.format(iota(0, Ranges.length)));
}
}
/+
Sets the rightmost element. Only present if `back` is defined and
each constituent range has assignable elements.
+/
static if (isBackWellDefined && allSatisfy!(hasAssignableElements, Ranges))
@property void back()(ElementType v)
{
static if (allKnownSameLength)
{
static foreach (i; 0 .. Ranges.length)
ranges[i].back = v[i];
}
else
{
const backIndex = length - 1;
static foreach (i; 0 .. Ranges.length)
ranges[i][backIndex] = v[i];
}
}
/+
Calls `popFront` on each constituent range.
+/
void popFront()
{
static foreach (i; 0 .. Ranges.length)
ranges[i].popFront();
}
/+
Pops the rightmost element. Present if `back` is defined.
+/
static if (isBackWellDefined)
void popBack()
{
static if (allKnownSameLength)
{
static foreach (i; 0 .. Ranges.length)
ranges[i].popBack;
}
else
{
const len = length;
static foreach (i; 0 .. Ranges.length)
static if (!isInfinite!(Ranges[i]))
if (ranges[i].length == len)
ranges[i].popBack();
}
}
/+
Returns the length of this range. Defined if at least one
constituent range defines `length` and the other ranges all also
define `length` or are infinite, or if at least one constituent
range defines `length` and there is a compile-time guarantee that
all ranges have the same length (in `allKnownSameLength`).
+/
static if (allKnownSameLength
? anySatisfy!(hasLength, Ranges)
: (anySatisfy!(hasLength, Ranges)
&& allSatisfy!(templateOr!(isInfinite, hasLength), Ranges)))
{
@property size_t length()
{
static if (allKnownSameLength)
{
static foreach (i, Range; Ranges)
{
static if (hasLength!Range && !anySatisfy!(hasLength, Ranges[0 .. i]))
return ranges[i].length;
}
}
else
{
static foreach (i, Range; Ranges)
static if (hasLength!Range)
{
static if (!anySatisfy!(hasLength, Ranges[0 .. i]))
size_t minLen = ranges[i].length;
else
{{
const x = ranges[i].length;
if (x < minLen) minLen = x;
}}
}
return minLen;
}
}
alias opDollar = length;
}
/+
Returns a slice of the range. Defined if all constituent ranges
support slicing.
+/
static if (allSatisfy!(hasSlicing, Ranges))
{
// Note: we will know that all elements of the resultant range
// will have the same length but we cannot change `allKnownSameLength`
// because the `hasSlicing` predicate tests that the result returned
// by `opSlice` has the same type as the receiver.
auto opSlice()(size_t from, size_t to)
{
//(ranges[0][from .. to], ranges[1][from .. to], ...)
enum sliceArgs = `(%(ranges[%s][from .. to]%|, %))`.format(iota(0, Ranges.length));
static if (__traits(compiles, mixin(`typeof(this)`~sliceArgs)))
return mixin(`typeof(this)`~sliceArgs);
else
// The type is different anyway so we might as well
// explicitly set allKnownSameLength.
return mixin(`ZipShortest!(Yes.allKnownSameLength, staticMap!(Take, Ranges))`
~sliceArgs);
}
}
/+
Returns the `n`th element in the composite range. Defined if all
constituent ranges offer random access.
+/
static if (allSatisfy!(isRandomAccessRange, Ranges))
ElementType opIndex()(size_t n)
{
return mixin(`typeof(return)(%(ranges[%s][n]%|, %))`.format(iota(0, Ranges.length)));
}
/+
Sets the `n`th element in the composite range. Defined if all
constituent ranges offer random access and have assignable elements.
+/
static if (allSatisfy!(isRandomAccessRange, Ranges)
&& allSatisfy!(hasAssignableElements, Ranges))
void opIndexAssign()(ElementType v, size_t n)
{
static foreach (i; 0 .. Ranges.length)
ranges[i][n] = v[i];
}
/+
Destructively reads the `n`th element in the composite
range. Defined if all constituent ranges offer random
access and have mobile elements.
+/
static if (allSatisfy!(isRandomAccessRange, Ranges)
&& allSatisfy!(hasMobileElements, Ranges))
ElementType moveAt()(size_t n)
{
return mixin(`typeof(return)(%(ranges[%s].moveAt(n)%|, %))`.format(iota(0, Ranges.length)));
}
}
pure @system unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filter, map;
import std.algorithm.mutation : swap;
import std.algorithm.sorting : sort;
import std.exception : assertThrown, assertNotThrown;
import std.typecons : tuple;
int[] a = [ 1, 2, 3 ];
float[] b = [ 1.0, 2.0, 3.0 ];
foreach (e; zip(a, b))
{
assert(e[0] == e[1]);
}
swap(a[0], a[1]);
{
auto z = zip(a, b);
}
//swap(z.front(), z.back());
sort!("a[0] < b[0]")(zip(a, b));
assert(a == [1, 2, 3]);
assert(b == [2.0, 1.0, 3.0]);
auto z = zip(StoppingPolicy.requireSameLength, a, b);
assertNotThrown(z.popBack());
assertNotThrown(z.popBack());
assertNotThrown(z.popBack());
assert(z.empty);
assertThrown(z.popBack());
a = [ 1, 2, 3 ];
b = [ 1.0, 2.0, 3.0 ];
sort!("a[0] > b[0]")(zip(StoppingPolicy.requireSameLength, a, b));
assert(a == [3, 2, 1]);
assert(b == [3.0, 2.0, 1.0]);
a = [];
b = [];
assert(zip(StoppingPolicy.requireSameLength, a, b).empty);
// Test infiniteness propagation.
static assert(isInfinite!(typeof(zip(repeat(1), repeat(1)))));
// Test stopping policies with both value and reference.
auto a1 = [1, 2];
auto a2 = [1, 2, 3];
auto stuff = tuple(tuple(a1, a2),
tuple(filter!"a"(a1), filter!"a"(a2)));
alias FOO = Zip!(immutable(int)[], immutable(float)[]);
foreach (t; stuff.expand)
{
auto arr1 = t[0];
auto arr2 = t[1];
auto zShortest = zip(arr1, arr2);
assert(equal(map!"a[0]"(zShortest), [1, 2]));
assert(equal(map!"a[1]"(zShortest), [1, 2]));
try {
auto zSame = zip(StoppingPolicy.requireSameLength, arr1, arr2);
foreach (elem; zSame) {}
assert(0);
} catch (Throwable) { /* It's supposed to throw.*/ }
auto zLongest = zip(StoppingPolicy.longest, arr1, arr2);
assert(!zLongest.ranges[0].empty);
assert(!zLongest.ranges[1].empty);
zLongest.popFront();
zLongest.popFront();
assert(!zLongest.empty);
assert(zLongest.ranges[0].empty);
assert(!zLongest.ranges[1].empty);
zLongest.popFront();
assert(zLongest.empty);
}
// BUG 8900
assert(zip([1, 2], repeat('a')).array == [tuple(1, 'a'), tuple(2, 'a')]);
assert(zip(repeat('a'), [1, 2]).array == [tuple('a', 1), tuple('a', 2)]);
// Issue 18524 - moveBack instead performs moveFront
{
auto r = zip([1,2,3]);
assert(r.moveBack()[0] == 3);
assert(r.moveFront()[0] == 1);
}
// Doesn't work yet. Issues w/ emplace.
// static assert(is(Zip!(immutable int[], immutable float[])));
// These unittests pass, but make the compiler consume an absurd amount
// of RAM and time. Therefore, they should only be run if explicitly
// uncommented when making changes to Zip. Also, running them using
// make -fwin32.mak unittest makes the compiler completely run out of RAM.
// You need to test just this module.
/+
foreach (DummyType1; AllDummyRanges)
{
DummyType1 d1;
foreach (DummyType2; AllDummyRanges)
{
DummyType2 d2;
auto r = zip(d1, d2);
assert(equal(map!"a[0]"(r), [1,2,3,4,5,6,7,8,9,10]));
assert(equal(map!"a[1]"(r), [1,2,3,4,5,6,7,8,9,10]));
static if (isForwardRange!DummyType1 && isForwardRange!DummyType2)
{
static assert(isForwardRange!(typeof(r)));
}
static if (isBidirectionalRange!DummyType1 &&
isBidirectionalRange!DummyType2) {
static assert(isBidirectionalRange!(typeof(r)));
}
static if (isRandomAccessRange!DummyType1 &&
isRandomAccessRange!DummyType2) {
static assert(isRandomAccessRange!(typeof(r)));
}
}
}
+/
}
nothrow pure @safe unittest
{
import std.algorithm.sorting : sort;
auto a = [5,4,3,2,1];
auto b = [3,1,2,5,6];
auto z = zip(a, b);
sort!"a[0] < b[0]"(z);
assert(a == [1, 2, 3, 4, 5]);
assert(b == [6, 5, 2, 1, 3]);
}
nothrow pure @safe unittest
{
import std.algorithm.comparison : equal;
import std.typecons : tuple;
auto LL = iota(1L, 1000L);
auto z = zip(LL, [4]);
assert(equal(z, [tuple(1L,4)]));
auto LL2 = iota(0L, 500L);
auto z2 = zip([7], LL2);
assert(equal(z2, [tuple(7, 0L)]));
}
// Text for Issue 11196
@safe pure unittest
{
import std.exception : assertThrown;
static struct S { @disable this(); }
assert(zip((S[5]).init[]).length == 5);
assert(zip(StoppingPolicy.longest, cast(S[]) null, new int[1]).length == 1);
assertThrown(zip(StoppingPolicy.longest, cast(S[]) null, new int[1]).front);
}
@nogc nothrow @safe pure unittest //12007
{
static struct R
{
enum empty = false;
void popFront(){}
int front(){return 1;} @property
R save(){return this;} @property
void opAssign(R) @disable;
}
R r;
auto z = zip(r, r);
assert(z.save == z);
}
nothrow pure @system unittest
{
import std.typecons : tuple;
auto r1 = [0,1,2];
auto r2 = [1,2,3];
auto z1 = zip(refRange(&r1), refRange(&r2));
auto z2 = z1.save;
z1.popFront();
assert(z1.front == tuple(1,2));
assert(z2.front == tuple(0,1));
}
@nogc nothrow pure @safe unittest
{
// Test zip's `back` and `length` with non-equal ranges.
static struct NonSliceableRandomAccess
{
private int[] a;
@property ref front()
{
return a.front;
}
@property ref back()
{
return a.back;
}
ref opIndex(size_t i)
{
return a[i];
}
void popFront()
{
a.popFront();
}
void popBack()
{
a.popBack();
}
auto moveFront()
{
return a.moveFront();
}
auto moveBack()
{
return a.moveBack();
}
auto moveAt(size_t i)
{
return a.moveAt(i);
}
bool empty() const
{
return a.empty;
}
size_t length() const
{
return a.length;
}
typeof(this) save()
{
return this;
}
}
static assert(isRandomAccessRange!NonSliceableRandomAccess);
static assert(!hasSlicing!NonSliceableRandomAccess);
static foreach (iteration; 0 .. 2)
{{
int[5] data = [101, 102, 103, 201, 202];
static if (iteration == 0)
{
auto r1 = NonSliceableRandomAccess(data[0 .. 3]);
auto r2 = NonSliceableRandomAccess(data[3 .. 5]);
}
else
{
auto r1 = data[0 .. 3];
auto r2 = data[3 .. 5];
}
auto z = zip(r1, r2);
static assert(isRandomAccessRange!(typeof(z)));
assert(z.length == 2);
assert(z.back[0] == 102 && z.back[1] == 202);
z.back = typeof(z.back)(-102, -202);// Assign to back.
assert(z.back[0] == -102 && z.back[1] == -202);
z.popBack();
assert(z.length == 1);
assert(z.back[0] == 101 && z.back[1] == 201);
z.front = typeof(z.front)(-101, -201);
assert(z.moveBack() == typeof(z.back)(-101, -201));
z.popBack();
assert(z.empty);
}}
}
@nogc nothrow pure @safe unittest
{
// Test opSlice on infinite `zip`.
auto z = zip(repeat(1), repeat(2));
assert(hasSlicing!(typeof(z)));
auto slice = z[10 .. 20];
assert(slice.length == 10);
static assert(!is(typeof(z) == typeof(slice)));
}
/*
Generate lockstep's opApply function as a mixin string.
If withIndex is true prepend a size_t index to the delegate.
*/
private string lockstepMixin(Ranges...)(bool withIndex, bool reverse)
{
import std.format : format;
string[] params;
string[] emptyChecks;
string[] dgArgs;
string[] popFronts;
string indexDef;
string indexInc;
if (withIndex)
{
params ~= "size_t";
dgArgs ~= "index";
if (reverse)
{
indexDef = q{
size_t index = ranges[0].length-1;
enforce(_stoppingPolicy == StoppingPolicy.requireSameLength,
"lockstep can only be used with foreach_reverse when stoppingPolicy == requireSameLength");
foreach (range; ranges[1..$])
enforce(range.length == ranges[0].length);
};
indexInc = "--index;";
}
else
{
indexDef = "size_t index = 0;";
indexInc = "++index;";
}
}
foreach (idx, Range; Ranges)
{
params ~= format("%sElementType!(Ranges[%s])", hasLvalueElements!Range ? "ref " : "", idx);
emptyChecks ~= format("!ranges[%s].empty", idx);
if (reverse)
{
dgArgs ~= format("ranges[%s].back", idx);
popFronts ~= format("ranges[%s].popBack();", idx);
}
else
{
dgArgs ~= format("ranges[%s].front", idx);
popFronts ~= format("ranges[%s].popFront();", idx);
}
}
string name = reverse ? "opApplyReverse" : "opApply";
return format(
q{
int %s(scope int delegate(%s) dg)
{
import std.exception : enforce;
auto ranges = _ranges;
int res;
%s
while (%s)
{
res = dg(%s);
if (res) break;
%s
%s
}
if (_stoppingPolicy == StoppingPolicy.requireSameLength)
{
foreach (range; ranges)
enforce(range.empty);
}
return res;
}
}, name, params.join(", "), indexDef,
emptyChecks.join(" && "), dgArgs.join(", "),
popFronts.join("\n "),
indexInc);
}
/**
Iterate multiple ranges in lockstep using a `foreach` loop. In contrast to
$(LREF zip) it allows reference access to its elements. If only a single
range is passed in, the `Lockstep` aliases itself away. If the
ranges are of different lengths and `s` == `StoppingPolicy.shortest`
stop after the shortest range is empty. If the ranges are of different
lengths and `s` == `StoppingPolicy.requireSameLength`, throw an
exception. `s` may not be `StoppingPolicy.longest`, and passing this
will throw an exception.
Iterating over `Lockstep` in reverse and with an index is only possible
when `s` == `StoppingPolicy.requireSameLength`, in order to preserve
indexes. If an attempt is made at iterating in reverse when `s` ==
`StoppingPolicy.shortest`, an exception will be thrown.
By default `StoppingPolicy` is set to `StoppingPolicy.shortest`.
Limitations: The `pure`, `@safe`, `@nogc`, or `nothrow` attributes cannot be
inferred for `lockstep` iteration. $(LREF zip) can infer the first two due to
a different implementation.
See_Also: $(LREF zip)
`lockstep` is similar to $(LREF zip), but `zip` bundles its
elements and returns a range.
`lockstep` also supports reference access.
Use `zip` if you want to pass the result to a range function.
*/
struct Lockstep(Ranges...)
if (Ranges.length > 1 && allSatisfy!(isInputRange, Ranges))
{
///
this(R ranges, StoppingPolicy sp = StoppingPolicy.shortest)
{
import std.exception : enforce;
_ranges = ranges;
enforce(sp != StoppingPolicy.longest,
"Can't use StoppingPolicy.Longest on Lockstep.");
_stoppingPolicy = sp;
}
mixin(lockstepMixin!Ranges(false, false));
mixin(lockstepMixin!Ranges(true, false));
static if (allSatisfy!(isBidirectionalRange, Ranges))
{
mixin(lockstepMixin!Ranges(false, true));
static if (allSatisfy!(hasLength, Ranges))
{
mixin(lockstepMixin!Ranges(true, true));
}
else
{
mixin(lockstepReverseFailMixin!Ranges(true));
}
}
else
{
mixin(lockstepReverseFailMixin!Ranges(false));
mixin(lockstepReverseFailMixin!Ranges(true));
}
private:
alias R = Ranges;
R _ranges;
StoppingPolicy _stoppingPolicy;
}
/// Ditto
Lockstep!(Ranges) lockstep(Ranges...)(Ranges ranges)
if (allSatisfy!(isInputRange, Ranges))
{
return Lockstep!(Ranges)(ranges);
}
/// Ditto
Lockstep!(Ranges) lockstep(Ranges...)(Ranges ranges, StoppingPolicy s)
if (allSatisfy!(isInputRange, Ranges))
{
static if (Ranges.length > 1)
return Lockstep!Ranges(ranges, s);
else
return ranges[0];
}
///
@system unittest
{
auto arr1 = [1,2,3,4,5,100];
auto arr2 = [6,7,8,9,10];
foreach (ref a, b; lockstep(arr1, arr2))
{
a += b;
}
assert(arr1 == [7,9,11,13,15,100]);
/// Lockstep also supports iterating with an index variable:
foreach (index, a, b; lockstep(arr1, arr2))
{
assert(arr1[index] == a);
assert(arr2[index] == b);
}
}
@system unittest // Bugzilla 15860: foreach_reverse on lockstep
{
auto arr1 = [0, 1, 2, 3];
auto arr2 = [4, 5, 6, 7];
size_t n = arr1.length -1;
foreach_reverse (index, a, b; lockstep(arr1, arr2, StoppingPolicy.requireSameLength))
{
assert(n == index);
assert(index == a);
assert(arr1[index] == a);
assert(arr2[index] == b);
n--;
}
auto arr3 = [4, 5];
n = 1;
foreach_reverse (a, b; lockstep(arr1, arr3))
{
assert(a == arr1[$-n] && b == arr3[$-n]);
n++;
}
}
@system unittest
{
import std.algorithm.iteration : filter;
import std.conv : to;
// The filters are to make these the lowest common forward denominator ranges,
// i.e. w/o ref return, random access, length, etc.
auto foo = filter!"a"([1,2,3,4,5]);
immutable bar = [6f,7f,8f,9f,10f].idup;
auto l = lockstep(foo, bar);
// Should work twice. These are forward ranges with implicit save.
foreach (i; 0 .. 2)
{
uint[] res1;
float[] res2;
foreach (a, ref b; l)
{
res1 ~= a;
res2 ~= b;
}
assert(res1 == [1,2,3,4,5]);
assert(res2 == [6,7,8,9,10]);
assert(bar == [6f,7f,8f,9f,10f]);
}
// Doc example.
auto arr1 = [1,2,3,4,5];
auto arr2 = [6,7,8,9,10];
foreach (ref a, ref b; lockstep(arr1, arr2))
{
a += b;
}
assert(arr1 == [7,9,11,13,15]);
// Make sure StoppingPolicy.requireSameLength doesn't throw.
auto ls = lockstep(arr1, arr2, StoppingPolicy.requireSameLength);
int k = 1;
foreach (a, b; ls)
{
assert(a - b == k);
++k;
}
// Make sure StoppingPolicy.requireSameLength throws.
arr2.popBack();
ls = lockstep(arr1, arr2, StoppingPolicy.requireSameLength);
try {
foreach (a, b; ls) {}
assert(0);
} catch (Exception) {}
// Just make sure 1-range case instantiates. This hangs the compiler
// when no explicit stopping policy is specified due to Bug 4652.
auto stuff = lockstep([1,2,3,4,5], StoppingPolicy.shortest);
foreach (i, a; stuff)
{
assert(stuff[i] == a);
}
// Test with indexing.
uint[] res1;
float[] res2;
size_t[] indices;
foreach (i, a, b; lockstep(foo, bar))
{
indices ~= i;
res1 ~= a;
res2 ~= b;
}
assert(indices == to!(size_t[])([0, 1, 2, 3, 4]));
assert(res1 == [1,2,3,4,5]);
assert(res2 == [6f,7f,8f,9f,10f]);
// Make sure we've worked around the relevant compiler bugs and this at least
// compiles w/ >2 ranges.
lockstep(foo, foo, foo);
// Make sure it works with const.
const(int[])[] foo2 = [[1, 2, 3]];
const(int[])[] bar2 = [[4, 5, 6]];
auto c = chain(foo2, bar2);
foreach (f, b; lockstep(c, c)) {}
// Regression 10468
foreach (x, y; lockstep(iota(0, 10), iota(0, 10))) { }
}
@system unittest
{
struct RvalueRange
{
int[] impl;
@property bool empty() { return impl.empty; }
@property int front() { return impl[0]; } // N.B. non-ref
void popFront() { impl.popFront(); }
}
auto data1 = [ 1, 2, 3, 4 ];
auto data2 = [ 5, 6, 7, 8 ];
auto r1 = RvalueRange(data1);
auto r2 = data2;
foreach (a, ref b; lockstep(r1, r2))
{
a++;
b++;
}
assert(data1 == [ 1, 2, 3, 4 ]); // changes to a do not propagate to data
assert(data2 == [ 6, 7, 8, 9 ]); // but changes to b do.
// Since r1 is by-value only, the compiler should reject attempts to
// foreach over it with ref.
static assert(!__traits(compiles, {
foreach (ref a, ref b; lockstep(r1, r2)) { a++; }
}));
}
private string lockstepReverseFailMixin(Ranges...)(bool withIndex)
{
import std.format : format;
string[] params;
string message;
if (withIndex)
{
message = "Indexed reverse iteration with lockstep is only supported"
~"if all ranges are bidirectional and have a length.\n";
}
else
{
message = "Reverse iteration with lockstep is only supported if all ranges are bidirectional.\n";
}
if (withIndex)
{
params ~= "size_t";
}
foreach (idx, Range; Ranges)
{
params ~= format("%sElementType!(Ranges[%s])", hasLvalueElements!Range ? "ref " : "", idx);
}
return format(
q{
int opApplyReverse()(scope int delegate(%s) dg)
{
static assert(false, "%s");
}
}, params.join(", "), message);
}
// For generic programming, make sure Lockstep!(Range) is well defined for a
// single range.
template Lockstep(Range)
{
alias Lockstep = Range;
}
/**
Creates a mathematical sequence given the initial values and a
recurrence function that computes the next value from the existing
values. The sequence comes in the form of an infinite forward
range. The type `Recurrence` itself is seldom used directly; most
often, recurrences are obtained by calling the function $(D
recurrence).
When calling `recurrence`, the function that computes the next
value is specified as a template argument, and the initial values in
the recurrence are passed as regular arguments. For example, in a
Fibonacci sequence, there are two initial values (and therefore a
state size of 2) because computing the next Fibonacci value needs the
past two values.
The signature of this function should be:
----
auto fun(R)(R state, size_t n)
----
where `n` will be the index of the current value, and `state` will be an
opaque state vector that can be indexed with array-indexing notation
`state[i]`, where valid values of `i` range from $(D (n - 1)) to
$(D (n - State.length)).
If the function is passed in string form, the state has name `"a"`
and the zero-based index in the recurrence has name `"n"`. The
given string must return the desired value for `a[n]` given
`a[n - 1]`, `a[n - 2]`, `a[n - 3]`,..., `a[n - stateSize]`. The
state size is dictated by the number of arguments passed to the call
to `recurrence`. The `Recurrence` struct itself takes care of
managing the recurrence's state and shifting it appropriately.
*/
struct Recurrence(alias fun, StateType, size_t stateSize)
{
import std.functional : binaryFun;
StateType[stateSize] _state;
size_t _n;
this(StateType[stateSize] initial) { _state = initial; }
void popFront()
{
static auto trustedCycle(ref typeof(_state) s) @trusted
{
return cycle(s);
}
// The cast here is reasonable because fun may cause integer
// promotion, but needs to return a StateType to make its operation
// closed. Therefore, we have no other choice.
_state[_n % stateSize] = cast(StateType) binaryFun!(fun, "a", "n")(
trustedCycle(_state), _n + stateSize);
++_n;
}
@property StateType front()
{
return _state[_n % stateSize];
}
@property typeof(this) save()
{
return this;
}
enum bool empty = false;
}
///
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
// The Fibonacci numbers, using function in string form:
// a[0] = 1, a[1] = 1, and compute a[n+1] = a[n-1] + a[n]
auto fib = recurrence!("a[n-1] + a[n-2]")(1, 1);
assert(fib.take(10).equal([1, 1, 2, 3, 5, 8, 13, 21, 34, 55]));
// The factorials, using function in lambda form:
auto fac = recurrence!((a,n) => a[n-1] * n)(1);
assert(take(fac, 10).equal([
1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880
]));
// The triangular numbers, using function in explicit form:
static size_t genTriangular(R)(R state, size_t n)
{
return state[n-1] + n;
}
auto tri = recurrence!genTriangular(0);
assert(take(tri, 10).equal([0, 1, 3, 6, 10, 15, 21, 28, 36, 45]));
}
/// Ditto
Recurrence!(fun, CommonType!(State), State.length)
recurrence(alias fun, State...)(State initial)
{
CommonType!(State)[State.length] state;
foreach (i, Unused; State)
{
state[i] = initial[i];
}
return typeof(return)(state);
}
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
auto fib = recurrence!("a[n-1] + a[n-2]")(1, 1);
static assert(isForwardRange!(typeof(fib)));
int[] witness = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ];
assert(equal(take(fib, 10), witness));
foreach (e; take(fib, 10)) {}
auto fact = recurrence!("n * a[n-1]")(1);
assert( equal(take(fact, 10), [1, 1, 2, 2*3, 2*3*4, 2*3*4*5, 2*3*4*5*6,
2*3*4*5*6*7, 2*3*4*5*6*7*8, 2*3*4*5*6*7*8*9][]) );
auto piapprox = recurrence!("a[n] + (n & 1 ? 4.0 : -4.0) / (2 * n + 3)")(4.0);
foreach (e; take(piapprox, 20)) {}
// Thanks to yebblies for this test and the associated fix
auto r = recurrence!"a[n-2]"(1, 2);
witness = [1, 2, 1, 2, 1];
assert(equal(take(r, 5), witness));
}
/**
`Sequence` is similar to `Recurrence` except that iteration is
presented in the so-called $(HTTP en.wikipedia.org/wiki/Closed_form,
closed form). This means that the `n`th element in the series is
computable directly from the initial values and `n` itself. This
implies that the interface offered by `Sequence` is a random-access
range, as opposed to the regular `Recurrence`, which only offers
forward iteration.
The state of the sequence is stored as a `Tuple` so it can be
heterogeneous.
*/
struct Sequence(alias fun, State)
{
private:
import std.functional : binaryFun;
alias compute = binaryFun!(fun, "a", "n");
alias ElementType = typeof(compute(State.init, cast(size_t) 1));
State _state;
size_t _n;
static struct DollarToken{}
public:
this(State initial, size_t n = 0)
{
_state = initial;
_n = n;
}
@property ElementType front()
{
return compute(_state, _n);
}
void popFront()
{
++_n;
}
enum opDollar = DollarToken();
auto opSlice(size_t lower, size_t upper)
in
{
assert(
upper >= lower,
"Attempting to slice a Sequence with a larger first argument than the second."
);
}
do
{
return typeof(this)(_state, _n + lower).take(upper - lower);
}
auto opSlice(size_t lower, DollarToken)
{
return typeof(this)(_state, _n + lower);
}
ElementType opIndex(size_t n)
{
return compute(_state, n + _n);
}
enum bool empty = false;
@property Sequence save() { return this; }
}
/// Ditto
auto sequence(alias fun, State...)(State args)
{
import std.typecons : Tuple, tuple;
alias Return = Sequence!(fun, Tuple!State);
return Return(tuple(args));
}
/// Odd numbers, using function in string form:
pure @safe nothrow @nogc unittest
{
auto odds = sequence!("a[0] + n * a[1]")(1, 2);
assert(odds.front == 1);
odds.popFront();
assert(odds.front == 3);
odds.popFront();
assert(odds.front == 5);
}
/// Triangular numbers, using function in lambda form:
pure @safe nothrow @nogc unittest
{
auto tri = sequence!((a,n) => n*(n+1)/2)();
// Note random access
assert(tri[0] == 0);
assert(tri[3] == 6);
assert(tri[1] == 1);
assert(tri[4] == 10);
assert(tri[2] == 3);
}
/// Fibonacci numbers, using function in explicit form:
@safe nothrow @nogc unittest
{
import std.math : pow, round, sqrt;
static ulong computeFib(S)(S state, size_t n)
{
// Binet's formula
return cast(ulong)(round((pow(state[0], n+1) - pow(state[1], n+1)) /
state[2]));
}
auto fib = sequence!computeFib(
(1.0 + sqrt(5.0)) / 2.0, // Golden Ratio
(1.0 - sqrt(5.0)) / 2.0, // Conjugate of Golden Ratio
sqrt(5.0));
// Note random access with [] operator
assert(fib[1] == 1);
assert(fib[4] == 5);
assert(fib[3] == 3);
assert(fib[2] == 2);
assert(fib[9] == 55);
}
pure @safe nothrow @nogc unittest
{
import std.typecons : Tuple, tuple;
auto y = Sequence!("a[0] + n * a[1]", Tuple!(int, int))(tuple(0, 4));
static assert(isForwardRange!(typeof(y)));
//@@BUG
//auto y = sequence!("a[0] + n * a[1]")(0, 4);
//foreach (e; take(y, 15))
{} //writeln(e);
auto odds = Sequence!("a[0] + n * a[1]", Tuple!(int, int))(
tuple(1, 2));
for (int currentOdd = 1; currentOdd <= 21; currentOdd += 2)
{
assert(odds.front == odds[0]);
assert(odds[0] == currentOdd);
odds.popFront();
}
}
pure @safe nothrow @nogc unittest
{
import std.algorithm.comparison : equal;
auto odds = sequence!("a[0] + n * a[1]")(1, 2);
static assert(hasSlicing!(typeof(odds)));
//Note: don't use drop or take as the target of an equal,
//since they'll both just forward to opSlice, making the tests irrelevant
// static slicing tests
assert(equal(odds[0 .. 5], only(1, 3, 5, 7, 9)));
assert(equal(odds[3 .. 7], only(7, 9, 11, 13)));
// relative slicing test, testing slicing is NOT agnostic of state
auto odds_less5 = odds.drop(5); //this should actually call odds[5 .. $]
assert(equal(odds_less5[0 .. 3], only(11, 13, 15)));
assert(equal(odds_less5[0 .. 10], odds[5 .. 15]));
//Infinite slicing tests
odds = odds[10 .. $];
assert(equal(odds.take(3), only(21, 23, 25)));
}
// Issue 5036
pure @safe nothrow unittest
{
auto s = sequence!((a, n) => new int)(0);
assert(s.front != s.front); // no caching
}
// iota
/**
Creates a range of values that span the given starting and stopping
values.
Params:
begin = The starting value.
end = The value that serves as the stopping criterion. This value is not
included in the range.
step = The value to add to the current value at each iteration.
Returns:
A range that goes through the numbers `begin`, $(D begin + step),
$(D begin + 2 * step), `...`, up to and excluding `end`.
The two-argument overloads have $(D step = 1). If $(D begin < end && step <
0) or $(D begin > end && step > 0) or $(D begin == end), then an empty range
is returned. If $(D step == 0) then $(D begin == end) is an error.
For built-in types, the range returned is a random access range. For
user-defined types that support `++`, the range is an input
range.
An integral iota also supports `in` operator from the right. It takes
the stepping into account, the integral won't be considered
contained if it falls between two consecutive values of the range.
`contains` does the same as in, but from lefthand side.
Example:
---
void main()
{
import std.stdio;
// The following groups all produce the same output of:
// 0 1 2 3 4
foreach (i; 0 .. 5)
writef("%s ", i);
writeln();
import std.range : iota;
foreach (i; iota(0, 5))
writef("%s ", i);
writeln();
writefln("%(%s %|%)", iota(0, 5));
import std.algorithm.iteration : map;
import std.algorithm.mutation : copy;
import std.format;
iota(0, 5).map!(i => format("%s ", i)).copy(stdout.lockingTextWriter());
writeln();
}
---
*/
auto iota(B, E, S)(B begin, E end, S step)
if ((isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E)))
&& isIntegral!S)
{
import std.conv : unsigned;
alias Value = CommonType!(Unqual!B, Unqual!E);
alias StepType = Unqual!S;
assert(step != 0 || begin == end);
static struct Result
{
private Value current, last;
private StepType step; // by convention, 0 if range is empty
this(Value current, Value pastLast, StepType step)
{
if (current < pastLast && step > 0)
{
// Iterating upward
assert(unsigned((pastLast - current) / step) <= size_t.max);
// Cast below can't fail because current < pastLast
this.last = cast(Value) (pastLast - 1);
this.last -= unsigned(this.last - current) % step;
}
else if (current > pastLast && step < 0)
{
// Iterating downward
assert(unsigned((current - pastLast) / (0 - step)) <= size_t.max);
// Cast below can't fail because current > pastLast
this.last = cast(Value) (pastLast + 1);
this.last += unsigned(current - this.last) % (0 - step);
}
else
{
// Initialize an empty range
this.step = 0;
return;
}
this.step = step;
this.current = current;
}
@property bool empty() const { return step == 0; }
@property inout(Value) front() inout { assert(!empty); return current; }
void popFront()
{
assert(!empty);
if (current == last) step = 0;
else current += step;
}
@property inout(Value) back() inout
{
assert(!empty);
return last;
}
void popBack()
{
assert(!empty);
if (current == last) step = 0;
else last -= step;
}
@property auto save() { return this; }
inout(Value) opIndex(ulong n) inout
{
assert(n < this.length);
// Just cast to Value here because doing so gives overflow behavior
// consistent with calling popFront() n times.
return cast(inout Value) (current + step * n);
}
auto opBinaryRight(string op)(Value val) const
if (op == "in")
{
if (empty) return false;
//cast to avoid becoming unsigned
auto supposedIndex = cast(StepType)(val - current) / step;
return supposedIndex < length && supposedIndex * step + current == val;
}
auto contains(Value x){return x in this;}
inout(Result) opSlice() inout { return this; }
inout(Result) opSlice(ulong lower, ulong upper) inout
{
assert(upper >= lower && upper <= this.length);
return cast(inout Result) Result(
cast(Value)(current + lower * step),
cast(Value)(current + upper * step),
step);
}
@property size_t length() const
{
if (step > 0)
return 1 + cast(size_t) (unsigned(last - current) / step);
if (step < 0)
return 1 + cast(size_t) (unsigned(current - last) / (0 - step));
return 0;
}
alias opDollar = length;
}
return Result(begin, end, step);
}
/// Ditto
auto iota(B, E)(B begin, E end)
if (isFloatingPoint!(CommonType!(B, E)))
{
return iota(begin, end, CommonType!(B, E)(1));
}
/// Ditto
auto iota(B, E)(B begin, E end)
if (isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E)))
{
import std.conv : unsigned;
alias Value = CommonType!(Unqual!B, Unqual!E);
static struct Result
{
private Value current, pastLast;
this(Value current, Value pastLast)
{
if (current < pastLast)
{
assert(unsigned(pastLast - current) <= size_t.max);
this.current = current;
this.pastLast = pastLast;
}
else
{
// Initialize an empty range
this.current = this.pastLast = current;
}
}
@property bool empty() const { return current == pastLast; }
@property inout(Value) front() inout { assert(!empty); return current; }
void popFront() { assert(!empty); ++current; }
@property inout(Value) back() inout { assert(!empty); return cast(inout(Value))(pastLast - 1); }
void popBack() { assert(!empty); --pastLast; }
@property auto save() { return this; }
inout(Value) opIndex(size_t n) inout
{
assert(n < this.length);
// Just cast to Value here because doing so gives overflow behavior
// consistent with calling popFront() n times.
return cast(inout Value) (current + n);
}
auto opBinaryRight(string op)(Value val) const
if (op == "in")
{
return current <= val && val < pastLast;
}
auto contains(Value x){return x in this;}
inout(Result) opSlice() inout { return this; }
inout(Result) opSlice(ulong lower, ulong upper) inout
{
assert(upper >= lower && upper <= this.length);
return cast(inout Result) Result(cast(Value)(current + lower),
cast(Value)(pastLast - (length - upper)));
}
@property size_t length() const
{
return cast(size_t)(pastLast - current);
}
alias opDollar = length;
}
return Result(begin, end);
}
/// Ditto
auto iota(E)(E end)
if (is(typeof(iota(E(0), end))))
{
E begin = E(0);
return iota(begin, end);
}
/// Ditto
// Specialization for floating-point types
auto iota(B, E, S)(B begin, E end, S step)
if (isFloatingPoint!(CommonType!(B, E, S)))
in
{
assert(step != 0, "iota: step must not be 0");
assert((end - begin) / step >= 0, "iota: incorrect startup parameters");
}
do
{
alias Value = Unqual!(CommonType!(B, E, S));
static struct Result
{
private Value start, step;
private size_t index, count;
this(Value start, Value end, Value step)
{
import std.conv : to;
this.start = start;
this.step = step;
immutable fcount = (end - start) / step;
count = to!size_t(fcount);
auto pastEnd = start + count * step;
if (step > 0)
{
if (pastEnd < end) ++count;
assert(start + count * step >= end);
}
else
{
if (pastEnd > end) ++count;
assert(start + count * step <= end);
}
}
@property bool empty() const { return index == count; }
@property Value front() const { assert(!empty); return start + step * index; }
void popFront()
{
assert(!empty);
++index;
}
@property Value back() const
{
assert(!empty);
return start + step * (count - 1);
}
void popBack()
{
assert(!empty);
--count;
}
@property auto save() { return this; }
Value opIndex(size_t n) const
{
assert(n < count);
return start + step * (n + index);
}
inout(Result) opSlice() inout
{
return this;
}
inout(Result) opSlice(size_t lower, size_t upper) inout
{
assert(upper >= lower && upper <= count);
Result ret = this;
ret.index += lower;
ret.count = upper - lower + ret.index;
return cast(inout Result) ret;
}
@property size_t length() const
{
return count - index;
}
alias opDollar = length;
}
return Result(begin, end, step);
}
///
pure @safe unittest
{
import std.algorithm.comparison : equal;
import std.math : approxEqual;
auto r = iota(0, 10, 1);
assert(equal(r, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
assert(equal(r, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
assert(3 in r);
assert(r.contains(3)); //Same as above
assert(!(10 in r));
assert(!(-8 in r));
r = iota(0, 11, 3);
assert(equal(r, [0, 3, 6, 9]));
assert(r[2] == 6);
assert(!(2 in r));
auto rf = iota(0.0, 0.5, 0.1);
assert(approxEqual(rf, [0.0, 0.1, 0.2, 0.3, 0.4]));
}
pure nothrow @nogc @safe unittest
{
import std.traits : Signed;
//float overloads use std.conv.to so can't be @nogc or nothrow
alias ssize_t = Signed!size_t;
assert(iota(ssize_t.max, 0, -1).length == ssize_t.max);
assert(iota(ssize_t.max, ssize_t.min, -1).length == size_t.max);
assert(iota(ssize_t.max, ssize_t.min, -2).length == 1 + size_t.max / 2);
assert(iota(ssize_t.min, ssize_t.max, 2).length == 1 + size_t.max / 2);
assert(iota(ssize_t.max, ssize_t.min, -3).length == size_t.max / 3);
}
debug @system unittest
{//check the contracts
import core.exception : AssertError;
import std.exception : assertThrown;
assertThrown!AssertError(iota(1,2,0));
assertThrown!AssertError(iota(0f,1f,0f));
assertThrown!AssertError(iota(1f,0f,0.1f));
assertThrown!AssertError(iota(0f,1f,-0.1f));
}
pure @system nothrow unittest
{
int[] a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
auto r1 = iota(a.ptr, a.ptr + a.length, 1);
assert(r1.front == a.ptr);
assert(r1.back == a.ptr + a.length - 1);
assert(&a[4] in r1);
}
pure @safe nothrow @nogc unittest
{
assert(iota(1UL, 0UL).length == 0);
assert(iota(1UL, 0UL, 1).length == 0);
assert(iota(0, 1, 1).length == 1);
assert(iota(1, 0, -1).length == 1);
assert(iota(0, 1, -1).length == 0);
assert(iota(ulong.max, 0).length == 0);
}
pure @safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.searching : count;
import std.math : approxEqual, nextUp, nextDown;
import std.meta : AliasSeq;
static assert(is(ElementType!(typeof(iota(0f))) == float));
static assert(hasLength!(typeof(iota(0, 2))));
auto r = iota(0, 10, 1);
assert(r[$ - 1] == 9);
assert(equal(r, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9][]));
auto rSlice = r[2 .. 8];
assert(equal(rSlice, [2, 3, 4, 5, 6, 7]));
rSlice.popFront();
assert(rSlice[0] == rSlice.front);
assert(rSlice.front == 3);
rSlice.popBack();
assert(rSlice[rSlice.length - 1] == rSlice.back);
assert(rSlice.back == 6);
rSlice = r[0 .. 4];
assert(equal(rSlice, [0, 1, 2, 3]));
assert(3 in rSlice);
assert(!(4 in rSlice));
auto rr = iota(10);
assert(equal(rr, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9][]));
r = iota(0, -10, -1);
assert(equal(r, [0, -1, -2, -3, -4, -5, -6, -7, -8, -9][]));
rSlice = r[3 .. 9];
assert(equal(rSlice, [-3, -4, -5, -6, -7, -8]));
r = iota(0, -6, -3);
assert(equal(r, [0, -3][]));
rSlice = r[1 .. 2];
assert(equal(rSlice, [-3]));
r = iota(0, -7, -3);
assert(equal(r, [0, -3, -6][]));
assert(0 in r);
assert(-6 in r);
rSlice = r[1 .. 3];
assert(equal(rSlice, [-3, -6]));
assert(!(0 in rSlice));
assert(!(-2 in rSlice));
assert(!(-5 in rSlice));
assert(!(3 in rSlice));
assert(!(-9 in rSlice));
r = iota(0, 11, 3);
assert(equal(r, [0, 3, 6, 9][]));
assert(r[2] == 6);
rSlice = r[1 .. 3];
assert(equal(rSlice, [3, 6]));
auto rf = iota(0.0, 0.5, 0.1);
assert(approxEqual(rf, [0.0, 0.1, 0.2, 0.3, 0.4][]));
assert(rf.length == 5);
rf.popFront();
assert(rf.length == 4);
auto rfSlice = rf[1 .. 4];
assert(rfSlice.length == 3);
assert(approxEqual(rfSlice, [0.2, 0.3, 0.4]));
rfSlice.popFront();
assert(approxEqual(rfSlice[0], 0.3));
rf.popFront();
assert(rf.length == 3);
rfSlice = rf[1 .. 3];
assert(rfSlice.length == 2);
assert(approxEqual(rfSlice, [0.3, 0.4]));
assert(approxEqual(rfSlice[0], 0.3));
// With something just above 0.5
rf = iota(0.0, nextUp(0.5), 0.1);
assert(approxEqual(rf, [0.0, 0.1, 0.2, 0.3, 0.4, 0.5][]));
rf.popBack();
assert(rf[rf.length - 1] == rf.back);
assert(approxEqual(rf.back, 0.4));
assert(rf.length == 5);
// going down
rf = iota(0.0, -0.5, -0.1);
assert(approxEqual(rf, [0.0, -0.1, -0.2, -0.3, -0.4][]));
rfSlice = rf[2 .. 5];
assert(approxEqual(rfSlice, [-0.2, -0.3, -0.4]));
rf = iota(0.0, nextDown(-0.5), -0.1);
assert(approxEqual(rf, [0.0, -0.1, -0.2, -0.3, -0.4, -0.5][]));
// iota of longs
auto rl = iota(5_000_000L);
assert(rl.length == 5_000_000L);
assert(0 in rl);
assert(4_000_000L in rl);
assert(!(-4_000_000L in rl));
assert(!(5_000_000L in rl));
// iota of longs with steps
auto iota_of_longs_with_steps = iota(50L, 101L, 10);
assert(iota_of_longs_with_steps.length == 6);
assert(equal(iota_of_longs_with_steps, [50L, 60L, 70L, 80L, 90L, 100L]));
// iota of unsigned zero length (issue 6222, actually trying to consume it
// is the only way to find something is wrong because the public
// properties are all correct)
auto iota_zero_unsigned = iota(0, 0u, 3);
assert(count(iota_zero_unsigned) == 0);
// unsigned reverse iota can be buggy if .length doesn't take them into
// account (issue 7982).
assert(iota(10u, 0u, -1).length == 10);
assert(iota(10u, 0u, -2).length == 5);
assert(iota(uint.max, uint.max-10, -1).length == 10);
assert(iota(uint.max, uint.max-10, -2).length == 5);
assert(iota(uint.max, 0u, -1).length == uint.max);
assert(20 in iota(20u, 10u, -2));
assert(16 in iota(20u, 10u, -2));
assert(!(15 in iota(20u, 10u, -2)));
assert(!(10 in iota(20u, 10u, -2)));
assert(!(uint.max in iota(20u, 10u, -1)));
assert(!(int.min in iota(20u, 10u, -1)));
assert(!(int.max in iota(20u, 10u, -1)));
// Issue 8920
static foreach (Type; AliasSeq!(byte, ubyte, short, ushort,
int, uint, long, ulong))
{{
Type val;
foreach (i; iota(cast(Type) 0, cast(Type) 10)) { val++; }
assert(val == 10);
}}
}
pure @safe nothrow unittest
{
import std.algorithm.mutation : copy;
auto idx = new size_t[100];
copy(iota(0, idx.length), idx);
}
@safe unittest
{
import std.meta : AliasSeq;
static foreach (range; AliasSeq!(iota(2, 27, 4),
iota(3, 9),
iota(2.7, 12.3, .1),
iota(3.2, 9.7)))
{{
const cRange = range;
const e = cRange.empty;
const f = cRange.front;
const b = cRange.back;
const i = cRange[2];
const s1 = cRange[];
const s2 = cRange[0 .. 3];
const l = cRange.length;
}}
}
@system unittest
{
//The ptr stuff can't be done at compile time, so we unfortunately end
//up with some code duplication here.
auto arr = [0, 5, 3, 5, 5, 7, 9, 2, 0, 42, 7, 6];
{
const cRange = iota(arr.ptr, arr.ptr + arr.length, 3);
const e = cRange.empty;
const f = cRange.front;
const b = cRange.back;
const i = cRange[2];
const s1 = cRange[];
const s2 = cRange[0 .. 3];
const l = cRange.length;
}
{
const cRange = iota(arr.ptr, arr.ptr + arr.length);
const e = cRange.empty;
const f = cRange.front;
const b = cRange.back;
const i = cRange[2];
const s1 = cRange[];
const s2 = cRange[0 .. 3];
const l = cRange.length;
}
}
@nogc nothrow pure @safe unittest
{
{
ushort start = 0, end = 10, step = 2;
foreach (i; iota(start, end, step))
static assert(is(typeof(i) == ushort));
}
{
ubyte start = 0, end = 255, step = 128;
uint x;
foreach (i; iota(start, end, step))
{
static assert(is(typeof(i) == ubyte));
++x;
}
assert(x == 2);
}
}
/* Generic overload that handles arbitrary types that support arithmetic
* operations.
*
* User-defined types such as $(REF BigInt, std,bigint) are also supported, as long
* as they can be incremented with `++` and compared with `<` or `==`.
*/
/// ditto
auto iota(B, E)(B begin, E end)
if (!isIntegral!(CommonType!(B, E)) &&
!isFloatingPoint!(CommonType!(B, E)) &&
!isPointer!(CommonType!(B, E)) &&
is(typeof((ref B b) { ++b; })) &&
(is(typeof(B.init < E.init)) || is(typeof(B.init == E.init))) )
{
static struct Result
{
B current;
E end;
@property bool empty()
{
static if (is(typeof(B.init < E.init)))
return !(current < end);
else static if (is(typeof(B.init != E.init)))
return current == end;
else
static assert(0);
}
@property auto front() { return current; }
void popFront()
{
assert(!empty);
++current;
}
}
return Result(begin, end);
}
@safe unittest
{
import std.algorithm.comparison : equal;
// Test iota() for a type that only supports ++ and != but does not have
// '<'-ordering.
struct Cyclic(int wrapAround)
{
int current;
this(int start) { current = start % wrapAround; }
bool opEquals(Cyclic c) const { return current == c.current; }
bool opEquals(int i) const { return current == i; }
void opUnary(string op)() if (op == "++")
{
current = (current + 1) % wrapAround;
}
}
alias Cycle5 = Cyclic!5;
// Easy case
auto i1 = iota(Cycle5(1), Cycle5(4));
assert(i1.equal([1, 2, 3]));
// Wraparound case
auto i2 = iota(Cycle5(3), Cycle5(2));
assert(i2.equal([3, 4, 0, 1 ]));
}
/**
Options for the $(LREF FrontTransversal) and $(LREF Transversal) ranges
(below).
*/
enum TransverseOptions
{
/**
When transversed, the elements of a range of ranges are assumed to
have different lengths (e.g. a jagged array).
*/
assumeJagged, //default
/**
The transversal enforces that the elements of a range of ranges have
all the same length (e.g. an array of arrays, all having the same
length). Checking is done once upon construction of the transversal
range.
*/
enforceNotJagged,
/**
The transversal assumes, without verifying, that the elements of a
range of ranges have all the same length. This option is useful if
checking was already done from the outside of the range.
*/
assumeNotJagged,
}
///
@safe pure unittest
{
import std.algorithm.comparison : equal;
import std.exception : assertThrown;
auto arr = [[1, 2], [3, 4, 5]];
auto r1 = arr.frontTransversal!(TransverseOptions.assumeJagged);
assert(r1.equal([1, 3]));
// throws on construction
assertThrown!Exception(arr.frontTransversal!(TransverseOptions.enforceNotJagged));
auto r2 = arr.frontTransversal!(TransverseOptions.assumeNotJagged);
assert(r2.equal([1, 3]));
// either assuming or checking for equal lengths makes
// the result a random access range
assert(r2[0] == 1);
static assert(!__traits(compiles, r1[0]));
}
/**
Given a range of ranges, iterate transversally through the first
elements of each of the enclosed ranges.
*/
struct FrontTransversal(Ror,
TransverseOptions opt = TransverseOptions.assumeJagged)
{
alias RangeOfRanges = Unqual!(Ror);
alias RangeType = .ElementType!RangeOfRanges;
alias ElementType = .ElementType!RangeType;
private void prime()
{
static if (opt == TransverseOptions.assumeJagged)
{
while (!_input.empty && _input.front.empty)
{
_input.popFront();
}
static if (isBidirectionalRange!RangeOfRanges)
{
while (!_input.empty && _input.back.empty)
{
_input.popBack();
}
}
}
}
/**
Construction from an input.
*/
this(RangeOfRanges input)
{
_input = input;
prime();
static if (opt == TransverseOptions.enforceNotJagged)
// (isRandomAccessRange!RangeOfRanges
// && hasLength!RangeType)
{
import std.exception : enforce;
if (empty) return;
immutable commonLength = _input.front.length;
foreach (e; _input)
{
enforce(e.length == commonLength);
}
}
}
/**
Forward range primitives.
*/
static if (isInfinite!RangeOfRanges)
{
enum bool empty = false;
}
else
{
@property bool empty()
{
static if (opt != TransverseOptions.assumeJagged)
{
if (!_input.empty)
return _input.front.empty;
}
return _input.empty;
}
}
/// Ditto
@property auto ref front()
{
assert(!empty, "Attempting to fetch the front of an empty FrontTransversal");
return _input.front.front;
}
/// Ditto
static if (hasMobileElements!RangeType)
{
ElementType moveFront()
{
return _input.front.moveFront();
}
}
static if (hasAssignableElements!RangeType)
{
@property void front(ElementType val)
{
_input.front.front = val;
}
}
/// Ditto
void popFront()
{
assert(!empty, "Attempting to popFront an empty FrontTransversal");
_input.popFront();
prime();
}
/**
Duplicates this `frontTransversal`. Note that only the encapsulating
range of range will be duplicated. Underlying ranges will not be
duplicated.
*/
static if (isForwardRange!RangeOfRanges)
{
@property FrontTransversal save()
{
return FrontTransversal(_input.save);
}
}
static if (isBidirectionalRange!RangeOfRanges)
{
/**
Bidirectional primitives. They are offered if $(D
isBidirectionalRange!RangeOfRanges).
*/
@property auto ref back()
{
assert(!empty, "Attempting to fetch the back of an empty FrontTransversal");
return _input.back.front;
}
/// Ditto
void popBack()
{
assert(!empty, "Attempting to popBack an empty FrontTransversal");
_input.popBack();
prime();
}
/// Ditto
static if (hasMobileElements!RangeType)
{
ElementType moveBack()
{
return _input.back.moveFront();
}
}
static if (hasAssignableElements!RangeType)
{
@property void back(ElementType val)
{
_input.back.front = val;
}
}
}
static if (isRandomAccessRange!RangeOfRanges &&
(opt == TransverseOptions.assumeNotJagged ||
opt == TransverseOptions.enforceNotJagged))
{
/**
Random-access primitive. It is offered if $(D
isRandomAccessRange!RangeOfRanges && (opt ==
TransverseOptions.assumeNotJagged || opt ==
TransverseOptions.enforceNotJagged)).
*/
auto ref opIndex(size_t n)
{
return _input[n].front;
}
/// Ditto
static if (hasMobileElements!RangeType)
{
ElementType moveAt(size_t n)
{
return _input[n].moveFront();
}
}
/// Ditto
static if (hasAssignableElements!RangeType)
{
void opIndexAssign(ElementType val, size_t n)
{
_input[n].front = val;
}
}
/// Ditto
static if (hasLength!RangeOfRanges)
{
@property size_t length()
{
return _input.length;
}
alias opDollar = length;
}
/**
Slicing if offered if `RangeOfRanges` supports slicing and all the
conditions for supporting indexing are met.
*/
static if (hasSlicing!RangeOfRanges)
{
typeof(this) opSlice(size_t lower, size_t upper)
{
return typeof(this)(_input[lower .. upper]);
}
}
}
auto opSlice() { return this; }
private:
RangeOfRanges _input;
}
/// Ditto
FrontTransversal!(RangeOfRanges, opt) frontTransversal(
TransverseOptions opt = TransverseOptions.assumeJagged,
RangeOfRanges)
(RangeOfRanges rr)
{
return typeof(return)(rr);
}
///
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
int[][] x = new int[][2];
x[0] = [1, 2];
x[1] = [3, 4];
auto ror = frontTransversal(x);
assert(equal(ror, [ 1, 3 ][]));
}
@safe unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges, DummyRange, ReturnBy;
static assert(is(FrontTransversal!(immutable int[][])));
foreach (DummyType; AllDummyRanges)
{
auto dummies =
[DummyType.init, DummyType.init, DummyType.init, DummyType.init];
foreach (i, ref elem; dummies)
{
// Just violate the DummyRange abstraction to get what I want.
elem.arr = elem.arr[i..$ - (3 - i)];
}
auto ft = frontTransversal!(TransverseOptions.assumeNotJagged)(dummies);
static if (isForwardRange!DummyType)
{
static assert(isForwardRange!(typeof(ft)));
}
assert(equal(ft, [1, 2, 3, 4]));
// Test slicing.
assert(equal(ft[0 .. 2], [1, 2]));
assert(equal(ft[1 .. 3], [2, 3]));
assert(ft.front == ft.moveFront());
assert(ft.back == ft.moveBack());
assert(ft.moveAt(1) == ft[1]);
// Test infiniteness propagation.
static assert(isInfinite!(typeof(frontTransversal(repeat("foo")))));
static if (DummyType.r == ReturnBy.Reference)
{
{
ft.front++;
scope(exit) ft.front--;
assert(dummies.front.front == 2);
}
{
ft.front = 5;
scope(exit) ft.front = 1;
assert(dummies[0].front == 5);
}
{
ft.back = 88;
scope(exit) ft.back = 4;
assert(dummies.back.front == 88);
}
{
ft[1] = 99;
scope(exit) ft[1] = 2;
assert(dummies[1].front == 99);
}
}
}
}
// Issue 16363
pure @safe nothrow unittest
{
import std.algorithm.comparison : equal;
int[][] darr = [[0, 1], [4, 5]];
auto ft = frontTransversal!(TransverseOptions.assumeNotJagged)(darr);
assert(equal(ft, [0, 4]));
static assert(isRandomAccessRange!(typeof(ft)));
}
// Bugzilla 16442
pure @safe nothrow unittest
{
int[][] arr = [[], []];
auto ft = frontTransversal!(TransverseOptions.assumeNotJagged)(arr);
assert(ft.empty);
}
// ditto
pure @safe unittest
{
int[][] arr = [[], []];
auto ft = frontTransversal!(TransverseOptions.enforceNotJagged)(arr);
assert(ft.empty);
}
/**
Given a range of ranges, iterate transversally through the
`n`th element of each of the enclosed ranges. This function
is similar to `unzip` in other languages.
Params:
opt = Controls the assumptions the function makes about the lengths
of the ranges
rr = An input range of random access ranges
Returns:
At minimum, an input range. Range primitives such as bidirectionality
and random access are given if the element type of `rr` provides them.
*/
struct Transversal(Ror,
TransverseOptions opt = TransverseOptions.assumeJagged)
{
private alias RangeOfRanges = Unqual!Ror;
private alias InnerRange = ElementType!RangeOfRanges;
private alias E = ElementType!InnerRange;
private void prime()
{
static if (opt == TransverseOptions.assumeJagged)
{
while (!_input.empty && _input.front.length <= _n)
{
_input.popFront();
}
static if (isBidirectionalRange!RangeOfRanges)
{
while (!_input.empty && _input.back.length <= _n)
{
_input.popBack();
}
}
}
}
/**
Construction from an input and an index.
*/
this(RangeOfRanges input, size_t n)
{
_input = input;
_n = n;
prime();
static if (opt == TransverseOptions.enforceNotJagged)
{
import std.exception : enforce;
if (empty) return;
immutable commonLength = _input.front.length;
foreach (e; _input)
{
enforce(e.length == commonLength);
}
}
}
/**
Forward range primitives.
*/
static if (isInfinite!(RangeOfRanges))
{
enum bool empty = false;
}
else
{
@property bool empty()
{
return _input.empty;
}
}
/// Ditto
@property auto ref front()
{
assert(!empty, "Attempting to fetch the front of an empty Transversal");
return _input.front[_n];
}
/// Ditto
static if (hasMobileElements!InnerRange)
{
E moveFront()
{
return _input.front.moveAt(_n);
}
}
/// Ditto
static if (hasAssignableElements!InnerRange)
{
@property void front(E val)
{
_input.front[_n] = val;
}
}
/// Ditto
void popFront()
{
assert(!empty, "Attempting to popFront an empty Transversal");
_input.popFront();
prime();
}
/// Ditto
static if (isForwardRange!RangeOfRanges)
{
@property typeof(this) save()
{
auto ret = this;
ret._input = _input.save;
return ret;
}
}
static if (isBidirectionalRange!RangeOfRanges)
{
/**
Bidirectional primitives. They are offered if $(D
isBidirectionalRange!RangeOfRanges).
*/
@property auto ref back()
{
assert(!empty, "Attempting to fetch the back of an empty Transversal");
return _input.back[_n];
}
/// Ditto
void popBack()
{
assert(!empty, "Attempting to popBack an empty Transversal");
_input.popBack();
prime();
}
/// Ditto
static if (hasMobileElements!InnerRange)
{
E moveBack()
{
return _input.back.moveAt(_n);
}
}
/// Ditto
static if (hasAssignableElements!InnerRange)
{
@property void back(E val)
{
_input.back[_n] = val;
}
}
}
static if (isRandomAccessRange!RangeOfRanges &&
(opt == TransverseOptions.assumeNotJagged ||
opt == TransverseOptions.enforceNotJagged))
{
/**
Random-access primitive. It is offered if $(D
isRandomAccessRange!RangeOfRanges && (opt ==
TransverseOptions.assumeNotJagged || opt ==
TransverseOptions.enforceNotJagged)).
*/
auto ref opIndex(size_t n)
{
return _input[n][_n];
}
/// Ditto
static if (hasMobileElements!InnerRange)
{
E moveAt(size_t n)
{
return _input[n].moveAt(_n);
}
}
/// Ditto
static if (hasAssignableElements!InnerRange)
{
void opIndexAssign(E val, size_t n)
{
_input[n][_n] = val;
}
}
/// Ditto
static if (hasLength!RangeOfRanges)
{
@property size_t length()
{
return _input.length;
}
alias opDollar = length;
}
/**
Slicing if offered if `RangeOfRanges` supports slicing and all the
conditions for supporting indexing are met.
*/
static if (hasSlicing!RangeOfRanges)
{
typeof(this) opSlice(size_t lower, size_t upper)
{
return typeof(this)(_input[lower .. upper], _n);
}
}
}
auto opSlice() { return this; }
private:
RangeOfRanges _input;
size_t _n;
}
/// Ditto
Transversal!(RangeOfRanges, opt) transversal
(TransverseOptions opt = TransverseOptions.assumeJagged, RangeOfRanges)
(RangeOfRanges rr, size_t n)
{
return typeof(return)(rr, n);
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
int[][] x = new int[][2];
x[0] = [1, 2];
x[1] = [3, 4];
auto ror = transversal(x, 1);
assert(equal(ror, [ 2, 4 ]));
}
/// The following code does a full unzip
@safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : map;
int[][] y = [[1, 2, 3], [4, 5, 6]];
auto z = y.front.walkLength.iota.map!(i => transversal(y, i));
assert(equal!equal(z, [[1, 4], [2, 5], [3, 6]]));
}
@safe unittest
{
import std.internal.test.dummyrange : DummyRange, Length, RangeType, ReturnBy;
int[][] x = new int[][2];
x[0] = [ 1, 2 ];
x[1] = [3, 4];
auto ror = transversal!(TransverseOptions.assumeNotJagged)(x, 1);
auto witness = [ 2, 4 ];
uint i;
foreach (e; ror) assert(e == witness[i++]);
assert(i == 2);
assert(ror.length == 2);
static assert(is(Transversal!(immutable int[][])));
// Make sure ref, assign is being propagated.
{
ror.front++;
scope(exit) ror.front--;
assert(x[0][1] == 3);
}
{
ror.front = 5;
scope(exit) ror.front = 2;
assert(x[0][1] == 5);
assert(ror.moveFront() == 5);
}
{
ror.back = 999;
scope(exit) ror.back = 4;
assert(x[1][1] == 999);
assert(ror.moveBack() == 999);
}
{
ror[0] = 999;
scope(exit) ror[0] = 2;
assert(x[0][1] == 999);
assert(ror.moveAt(0) == 999);
}
// Test w/o ref return.
alias D = DummyRange!(ReturnBy.Value, Length.Yes, RangeType.Random);
auto drs = [D.init, D.init];
foreach (num; 0 .. 10)
{
auto t = transversal!(TransverseOptions.enforceNotJagged)(drs, num);
assert(t[0] == t[1]);
assert(t[1] == num + 1);
}
static assert(isInfinite!(typeof(transversal(repeat([1,2,3]), 1))));
// Test slicing.
auto mat = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]];
auto mat1 = transversal!(TransverseOptions.assumeNotJagged)(mat, 1)[1 .. 3];
assert(mat1[0] == 6);
assert(mat1[1] == 10);
}
struct Transposed(RangeOfRanges,
TransverseOptions opt = TransverseOptions.assumeJagged)
if (isForwardRange!RangeOfRanges &&
isInputRange!(ElementType!RangeOfRanges) &&
hasAssignableElements!RangeOfRanges)
{
this(RangeOfRanges input)
{
this._input = input;
static if (opt == TransverseOptions.enforceNotJagged)
{
import std.exception : enforce;
if (empty) return;
immutable commonLength = _input.front.length;
foreach (e; _input)
{
enforce(e.length == commonLength);
}
}
}
@property auto front()
{
import std.algorithm.iteration : filter, map;
return _input.save
.filter!(a => !a.empty)
.map!(a => a.front);
}
void popFront()
{
// Advance the position of each subrange.
auto r = _input.save;
while (!r.empty)
{
auto e = r.front;
if (!e.empty)
{
e.popFront();
r.front = e;
}
r.popFront();
}
}
static if (isRandomAccessRange!(ElementType!RangeOfRanges))
{
auto ref opIndex(size_t n)
{
return transversal!opt(_input, n);
}
}
@property bool empty()
{
if (_input.empty) return true;
foreach (e; _input.save)
{
if (!e.empty) return false;
}
return true;
}
deprecated("This function is incorrect and will be removed November 2018. See the docs for more details.")
@property Transposed save()
{
return Transposed(_input.save);
}
auto opSlice() { return this; }
private:
RangeOfRanges _input;
}
@safe unittest
{
// Boundary case: transpose of empty range should be empty
int[][] ror = [];
assert(transposed(ror).empty);
}
// Issue 9507
@safe unittest
{
import std.algorithm.comparison : equal;
auto r = [[1,2], [3], [4,5], [], [6]];
assert(r.transposed.equal!equal([
[1, 3, 4, 6],
[2, 5]
]));
}
// Issue 17742
@safe unittest
{
import std.algorithm.iteration : map;
import std.algorithm.comparison : equal;
auto ror = 5.iota.map!(y => 5.iota.map!(x => x * y).array).array;
assert(ror[3][2] == 6);
auto result = transposed!(TransverseOptions.assumeNotJagged)(ror);
assert(result[2][3] == 6);
auto x = [[1,2,3],[4,5,6]];
auto y = transposed!(TransverseOptions.assumeNotJagged)(x);
assert(y.front.equal([1,4]));
assert(y[0].equal([1,4]));
assert(y[0][0] == 1);
assert(y[1].equal([2,5]));
assert(y[1][1] == 5);
auto yy = transposed!(TransverseOptions.enforceNotJagged)(x);
assert(yy.front.equal([1,4]));
assert(yy[0].equal([1,4]));
assert(yy[0][0] == 1);
assert(yy[1].equal([2,5]));
assert(yy[1][1] == 5);
auto z = x.transposed; // assumeJagged
assert(z.front.equal([1,4]));
assert(z[0].equal([1,4]));
assert(!is(typeof(z[0][0])));
}
@safe unittest
{
import std.exception : assertThrown;
auto r = [[1,2], [3], [4,5], [], [6]];
assertThrown(r.transposed!(TransverseOptions.enforceNotJagged));
}
/**
Given a range of ranges, returns a range of ranges where the $(I i)'th subrange
contains the $(I i)'th elements of the original subranges.
$(RED `Transposed` currently defines `save`, but does not work as a forward range.
Consuming a copy made with `save` will consume all copies, even the original sub-ranges
fed into `Transposed`.)
Params:
opt = Controls the assumptions the function makes about the lengths of the ranges (i.e. jagged or not)
rr = Range of ranges
*/
Transposed!(RangeOfRanges, opt) transposed
(TransverseOptions opt = TransverseOptions.assumeJagged, RangeOfRanges)
(RangeOfRanges rr)
if (isForwardRange!RangeOfRanges &&
isInputRange!(ElementType!RangeOfRanges) &&
hasAssignableElements!RangeOfRanges)
{
return Transposed!(RangeOfRanges, opt)(rr);
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
int[][] ror = [
[1, 2, 3],
[4, 5, 6]
];
auto xp = transposed(ror);
assert(equal!"a.equal(b)"(xp, [
[1, 4],
[2, 5],
[3, 6]
]));
}
///
@safe unittest
{
int[][] x = new int[][2];
x[0] = [1, 2];
x[1] = [3, 4];
auto tr = transposed(x);
int[][] witness = [ [ 1, 3 ], [ 2, 4 ] ];
uint i;
foreach (e; tr)
{
assert(array(e) == witness[i++]);
}
}
// Issue 8764
@safe unittest
{
import std.algorithm.comparison : equal;
ulong[1] t0 = [ 123 ];
assert(!hasAssignableElements!(typeof(t0[].chunks(1))));
assert(!is(typeof(transposed(t0[].chunks(1)))));
assert(is(typeof(transposed(t0[].chunks(1).array()))));
auto t1 = transposed(t0[].chunks(1).array());
assert(equal!"a.equal(b)"(t1, [[123]]));
}
/**
This struct takes two ranges, `source` and `indices`, and creates a view
of `source` as if its elements were reordered according to `indices`.
`indices` may include only a subset of the elements of `source` and
may also repeat elements.
`Source` must be a random access range. The returned range will be
bidirectional or random-access if `Indices` is bidirectional or
random-access, respectively.
*/
struct Indexed(Source, Indices)
if (isRandomAccessRange!Source && isInputRange!Indices &&
is(typeof(Source.init[ElementType!(Indices).init])))
{
this(Source source, Indices indices)
{
this._source = source;
this._indices = indices;
}
/// Range primitives
@property auto ref front()
{
assert(!empty, "Attempting to fetch the front of an empty Indexed");
return _source[_indices.front];
}
/// Ditto
void popFront()
{
assert(!empty, "Attempting to popFront an empty Indexed");
_indices.popFront();
}
static if (isInfinite!Indices)
{
enum bool empty = false;
}
else
{
/// Ditto
@property bool empty()
{
return _indices.empty;
}
}
static if (isForwardRange!Indices)
{
/// Ditto
@property typeof(this) save()
{
// Don't need to save _source because it's never consumed.
return typeof(this)(_source, _indices.save);
}
}
/// Ditto
static if (hasAssignableElements!Source)
{
@property auto ref front(ElementType!Source newVal)
{
assert(!empty);
return _source[_indices.front] = newVal;
}
}
static if (hasMobileElements!Source)
{
/// Ditto
auto moveFront()
{
assert(!empty);
return _source.moveAt(_indices.front);
}
}
static if (isBidirectionalRange!Indices)
{
/// Ditto
@property auto ref back()
{
assert(!empty, "Attempting to fetch the back of an empty Indexed");
return _source[_indices.back];
}
/// Ditto
void popBack()
{
assert(!empty, "Attempting to popBack an empty Indexed");
_indices.popBack();
}
/// Ditto
static if (hasAssignableElements!Source)
{
@property auto ref back(ElementType!Source newVal)
{
assert(!empty);
return _source[_indices.back] = newVal;
}
}
static if (hasMobileElements!Source)
{
/// Ditto
auto moveBack()
{
assert(!empty);
return _source.moveAt(_indices.back);
}
}
}
static if (hasLength!Indices)
{
/// Ditto
@property size_t length()
{
return _indices.length;
}
alias opDollar = length;
}
static if (isRandomAccessRange!Indices)
{
/// Ditto
auto ref opIndex(size_t index)
{
return _source[_indices[index]];
}
static if (hasSlicing!Indices)
{
/// Ditto
typeof(this) opSlice(size_t a, size_t b)
{
return typeof(this)(_source, _indices[a .. b]);
}
}
static if (hasAssignableElements!Source)
{
/// Ditto
auto opIndexAssign(ElementType!Source newVal, size_t index)
{
return _source[_indices[index]] = newVal;
}
}
static if (hasMobileElements!Source)
{
/// Ditto
auto moveAt(size_t index)
{
return _source.moveAt(_indices[index]);
}
}
}
// All this stuff is useful if someone wants to index an Indexed
// without adding a layer of indirection.
/**
Returns the source range.
*/
@property Source source()
{
return _source;
}
/**
Returns the indices range.
*/
@property Indices indices()
{
return _indices;
}
static if (isRandomAccessRange!Indices)
{
/**
Returns the physical index into the source range corresponding to a
given logical index. This is useful, for example, when indexing
an `Indexed` without adding another layer of indirection.
*/
size_t physicalIndex(size_t logicalIndex)
{
return _indices[logicalIndex];
}
///
@safe unittest
{
auto ind = indexed([1, 2, 3, 4, 5], [1, 3, 4]);
assert(ind.physicalIndex(0) == 1);
}
}
private:
Source _source;
Indices _indices;
}
/// Ditto
Indexed!(Source, Indices) indexed(Source, Indices)(Source source, Indices indices)
{
return typeof(return)(source, indices);
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
auto source = [1, 2, 3, 4, 5];
auto indices = [4, 3, 1, 2, 0, 4];
auto ind = indexed(source, indices);
assert(equal(ind, [5, 4, 2, 3, 1, 5]));
assert(equal(retro(ind), [5, 1, 3, 2, 4, 5]));
}
@safe unittest
{
{
auto ind = indexed([1, 2, 3, 4, 5], [1, 3, 4]);
assert(ind.physicalIndex(0) == 1);
}
auto source = [1, 2, 3, 4, 5];
auto indices = [4, 3, 1, 2, 0, 4];
auto ind = indexed(source, indices);
// When elements of indices are duplicated and Source has lvalue elements,
// these are aliased in ind.
ind[0]++;
assert(ind[0] == 6);
assert(ind[5] == 6);
}
@safe unittest
{
import std.internal.test.dummyrange : AllDummyRanges, propagatesLength,
propagatesRangeType, RangeType;
foreach (DummyType; AllDummyRanges)
{
auto d = DummyType.init;
auto r = indexed([1, 2, 3, 4, 5], d);
static assert(propagatesRangeType!(DummyType, typeof(r)));
static assert(propagatesLength!(DummyType, typeof(r)));
}
}
/**
This range iterates over fixed-sized chunks of size `chunkSize` of a
`source` range. `Source` must be an $(REF_ALTTEXT input range, isInputRange, std,range,primitives).
`chunkSize` must be greater than zero.
If `!isInfinite!Source` and `source.walkLength` is not evenly
divisible by `chunkSize`, the back element of this range will contain
fewer than `chunkSize` elements.
If `Source` is a forward range, the resulting range will be forward ranges as
well. Otherwise, the resulting chunks will be input ranges consuming the same
input: iterating over `front` will shrink the chunk such that subsequent
invocations of `front` will no longer return the full chunk, and calling
`popFront` on the outer range will invalidate any lingering references to
previous values of `front`.
Params:
source = Range from which the chunks will be selected
chunkSize = Chunk size
See_Also: $(LREF slide)
Returns: Range of chunks.
*/
struct Chunks(Source)
if (isInputRange!Source)
{
static if (isForwardRange!Source)
{
/// Standard constructor
this(Source source, size_t chunkSize)
{
assert(chunkSize != 0, "Cannot create a Chunk with an empty chunkSize");
_source = source;
_chunkSize = chunkSize;
}
/// Input range primitives. Always present.
@property auto front()
{
assert(!empty, "Attempting to fetch the front of an empty Chunks");
return _source.save.take(_chunkSize);
}
/// Ditto
void popFront()
{
assert(!empty, "Attempting to popFront and empty Chunks");
_source.popFrontN(_chunkSize);
}
static if (!isInfinite!Source)
/// Ditto
@property bool empty()
{
return _source.empty;
}
else
// undocumented
enum empty = false;
/// Forward range primitives. Only present if `Source` is a forward range.
@property typeof(this) save()
{
return typeof(this)(_source.save, _chunkSize);
}
static if (hasLength!Source)
{
/// Length. Only if `hasLength!Source` is `true`
@property size_t length()
{
// Note: _source.length + _chunkSize may actually overflow.
// We cast to ulong to mitigate the problem on x86 machines.
// For x64 machines, we just suppose we'll never overflow.
// The "safe" code would require either an extra branch, or a
// modulo operation, which is too expensive for such a rare case
return cast(size_t)((cast(ulong)(_source.length) + _chunkSize - 1) / _chunkSize);
}
//Note: No point in defining opDollar here without slicing.
//opDollar is defined below in the hasSlicing!Source section
}
static if (hasSlicing!Source)
{
//Used for various purposes
private enum hasSliceToEnd = is(typeof(Source.init[_chunkSize .. $]) == Source);
/**
Indexing and slicing operations. Provided only if
`hasSlicing!Source` is `true`.
*/
auto opIndex(size_t index)
{
immutable start = index * _chunkSize;
immutable end = start + _chunkSize;
static if (isInfinite!Source)
return _source[start .. end];
else
{
import std.algorithm.comparison : min;
immutable len = _source.length;
assert(start < len, "chunks index out of bounds");
return _source[start .. min(end, len)];
}
}
/// Ditto
static if (hasLength!Source)
typeof(this) opSlice(size_t lower, size_t upper)
{
import std.algorithm.comparison : min;
assert(lower <= upper && upper <= length, "chunks slicing index out of bounds");
immutable len = _source.length;
return chunks(_source[min(lower * _chunkSize, len) .. min(upper * _chunkSize, len)], _chunkSize);
}
else static if (hasSliceToEnd)
//For slicing an infinite chunk, we need to slice the source to the end.
typeof(takeExactly(this, 0)) opSlice(size_t lower, size_t upper)
{
assert(lower <= upper, "chunks slicing index out of bounds");
return chunks(_source[lower * _chunkSize .. $], _chunkSize).takeExactly(upper - lower);
}
static if (isInfinite!Source)
{
static if (hasSliceToEnd)
{
private static struct DollarToken{}
DollarToken opDollar()
{
return DollarToken();
}
//Slice to dollar
typeof(this) opSlice(size_t lower, DollarToken)
{
return typeof(this)(_source[lower * _chunkSize .. $], _chunkSize);
}
}
}
else
{
//Dollar token carries a static type, with no extra information.
//It can lazily transform into _source.length on algorithmic
//operations such as : chunks[$/2, $-1];
private static struct DollarToken
{
Chunks!Source* mom;
@property size_t momLength()
{
return mom.length;
}
alias momLength this;
}
DollarToken opDollar()
{
return DollarToken(&this);
}
//Slice overloads optimized for using dollar. Without this, to slice to end, we would...
//1. Evaluate chunks.length
//2. Multiply by _chunksSize
//3. To finally just compare it (with min) to the original length of source (!)
//These overloads avoid that.
typeof(this) opSlice(DollarToken, DollarToken)
{
static if (hasSliceToEnd)
return chunks(_source[$ .. $], _chunkSize);
else
{
immutable len = _source.length;
return chunks(_source[len .. len], _chunkSize);
}
}
typeof(this) opSlice(size_t lower, DollarToken)
{
import std.algorithm.comparison : min;
assert(lower <= length, "chunks slicing index out of bounds");
static if (hasSliceToEnd)
return chunks(_source[min(lower * _chunkSize, _source.length) .. $], _chunkSize);
else
{
immutable len = _source.length;
return chunks(_source[min(lower * _chunkSize, len) .. len], _chunkSize);
}
}
typeof(this) opSlice(DollarToken, size_t upper)
{
assert(upper == length, "chunks slicing index out of bounds");
return this[$ .. $];
}
}
}
//Bidirectional range primitives
static if (hasSlicing!Source && hasLength!Source)
{
/**
Bidirectional range primitives. Provided only if both
`hasSlicing!Source` and `hasLength!Source` are `true`.
*/
@property auto back()
{
assert(!empty, "back called on empty chunks");
immutable len = _source.length;
immutable start = (len - 1) / _chunkSize * _chunkSize;
return _source[start .. len];
}
/// Ditto
void popBack()
{
assert(!empty, "popBack() called on empty chunks");
immutable end = (_source.length - 1) / _chunkSize * _chunkSize;
_source = _source[0 .. end];
}
}
private:
Source _source;
size_t _chunkSize;
}
else // is input range only
{
import std.typecons : RefCounted;
static struct Chunk
{
private RefCounted!Impl impl;
@property bool empty() { return impl.curSizeLeft == 0 || impl.r.empty; }
@property auto front() { return impl.r.front; }
void popFront()
{
assert(impl.curSizeLeft > 0 && !impl.r.empty);
impl.curSizeLeft--;
impl.r.popFront();
}
}
static struct Impl
{
private Source r;
private size_t chunkSize;
private size_t curSizeLeft;
}
private RefCounted!Impl impl;
private this(Source r, size_t chunkSize)
{
impl = RefCounted!Impl(r, r.empty ? 0 : chunkSize, chunkSize);
}
@property bool empty() { return impl.chunkSize == 0; }
@property Chunk front() return { return Chunk(impl); }
void popFront()
{
impl.curSizeLeft -= impl.r.popFrontN(impl.curSizeLeft);
if (!impl.r.empty)
impl.curSizeLeft = impl.chunkSize;
else
impl.chunkSize = 0;
}
static assert(isInputRange!(typeof(this)));
}
}
/// Ditto
Chunks!Source chunks(Source)(Source source, size_t chunkSize)
if (isInputRange!Source)
{
return typeof(return)(source, chunkSize);
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
auto source = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
auto chunks = chunks(source, 4);
assert(chunks[0] == [1, 2, 3, 4]);
assert(chunks[1] == [5, 6, 7, 8]);
assert(chunks[2] == [9, 10]);
assert(chunks.back == chunks[2]);
assert(chunks.front == chunks[0]);
assert(chunks.length == 3);
assert(equal(retro(array(chunks)), array(retro(chunks))));
}
/// Non-forward input ranges are supported, but with limited semantics.
@system /*@safe*/ unittest // FIXME: can't be @safe because RefCounted isn't.
{
import std.algorithm.comparison : equal;
int i;
// The generator doesn't save state, so it cannot be a forward range.
auto inputRange = generate!(() => ++i).take(10);
// We can still process it in chunks, but it will be single-pass only.
auto chunked = inputRange.chunks(2);
assert(chunked.front.equal([1, 2]));
assert(chunked.front.empty); // Iterating the chunk has consumed it
chunked.popFront;
assert(chunked.front.equal([3, 4]));
}
@system /*@safe*/ unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : ReferenceInputRange;
auto data = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
auto r = new ReferenceInputRange!int(data).chunks(3);
assert(r.equal!equal([
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ],
[ 10 ]
]));
auto data2 = [ 1, 2, 3, 4, 5, 6 ];
auto r2 = new ReferenceInputRange!int(data2).chunks(3);
assert(r2.equal!equal([
[ 1, 2, 3 ],
[ 4, 5, 6 ]
]));
auto data3 = [ 1, 2, 3, 4, 5 ];
auto r3 = new ReferenceInputRange!int(data3).chunks(2);
assert(r3.front.equal([1, 2]));
r3.popFront();
assert(!r3.empty);
r3.popFront();
assert(r3.front.equal([5]));
}
@safe unittest
{
auto source = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
auto chunks = chunks(source, 4);
auto chunks2 = chunks.save;
chunks.popFront();
assert(chunks[0] == [5, 6, 7, 8]);
assert(chunks[1] == [9, 10]);
chunks2.popBack();
assert(chunks2[1] == [5, 6, 7, 8]);
assert(chunks2.length == 2);
static assert(isRandomAccessRange!(typeof(chunks)));
}
@safe unittest
{
import std.algorithm.comparison : equal;
//Extra toying with slicing and indexing.
auto chunks1 = [0, 0, 1, 1, 2, 2, 3, 3, 4].chunks(2);
auto chunks2 = [0, 0, 1, 1, 2, 2, 3, 3, 4, 4].chunks(2);
assert(chunks1.length == 5);
assert(chunks2.length == 5);
assert(chunks1[4] == [4]);
assert(chunks2[4] == [4, 4]);
assert(chunks1.back == [4]);
assert(chunks2.back == [4, 4]);
assert(chunks1[0 .. 1].equal([[0, 0]]));
assert(chunks1[0 .. 2].equal([[0, 0], [1, 1]]));
assert(chunks1[4 .. 5].equal([[4]]));
assert(chunks2[4 .. 5].equal([[4, 4]]));
assert(chunks1[0 .. 0].equal((int[][]).init));
assert(chunks1[5 .. 5].equal((int[][]).init));
assert(chunks2[5 .. 5].equal((int[][]).init));
//Fun with opDollar
assert(chunks1[$ .. $].equal((int[][]).init)); //Quick
assert(chunks2[$ .. $].equal((int[][]).init)); //Quick
assert(chunks1[$ - 1 .. $].equal([[4]])); //Semiquick
assert(chunks2[$ - 1 .. $].equal([[4, 4]])); //Semiquick
assert(chunks1[$ .. 5].equal((int[][]).init)); //Semiquick
assert(chunks2[$ .. 5].equal((int[][]).init)); //Semiquick
assert(chunks1[$ / 2 .. $ - 1].equal([[2, 2], [3, 3]])); //Slow
}
@safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filter;
//ForwardRange
auto r = filter!"true"([1, 2, 3, 4, 5]).chunks(2);
assert(equal!"equal(a, b)"(r, [[1, 2], [3, 4], [5]]));
//InfiniteRange w/o RA
auto fibsByPairs = recurrence!"a[n-1] + a[n-2]"(1, 1).chunks(2);
assert(equal!`equal(a, b)`(fibsByPairs.take(2), [[ 1, 1], [ 2, 3]]));
//InfiniteRange w/ RA and slicing
auto odds = sequence!("a[0] + n * a[1]")(1, 2);
auto oddsByPairs = odds.chunks(2);
assert(equal!`equal(a, b)`(oddsByPairs.take(2), [[ 1, 3], [ 5, 7]]));
//Requires phobos#991 for Sequence to have slice to end
static assert(hasSlicing!(typeof(odds)));
assert(equal!`equal(a, b)`(oddsByPairs[3 .. 5], [[13, 15], [17, 19]]));
assert(equal!`equal(a, b)`(oddsByPairs[3 .. $].take(2), [[13, 15], [17, 19]]));
}
/**
This range splits a `source` range into `chunkCount` chunks of
approximately equal length. `Source` must be a forward range with
known length.
Unlike $(LREF chunks), `evenChunks` takes a chunk count (not size).
The returned range will contain zero or more $(D source.length /
chunkCount + 1) elements followed by $(D source.length / chunkCount)
elements. If $(D source.length < chunkCount), some chunks will be empty.
`chunkCount` must not be zero, unless `source` is also empty.
*/
struct EvenChunks(Source)
if (isForwardRange!Source && hasLength!Source)
{
/// Standard constructor
this(Source source, size_t chunkCount)
{
assert(chunkCount != 0 || source.empty, "Cannot create EvenChunks with a zero chunkCount");
_source = source;
_chunkCount = chunkCount;
}
/// Forward range primitives. Always present.
@property auto front()
{
assert(!empty, "Attempting to fetch the front of an empty evenChunks");
return _source.save.take(_chunkPos(1));
}
/// Ditto
void popFront()
{
assert(!empty, "Attempting to popFront an empty evenChunks");
_source.popFrontN(_chunkPos(1));
_chunkCount--;
}
/// Ditto
@property bool empty()
{
return _source.empty;
}
/// Ditto
@property typeof(this) save()
{
return typeof(this)(_source.save, _chunkCount);
}
/// Length
@property size_t length() const
{
return _chunkCount;
}
//Note: No point in defining opDollar here without slicing.
//opDollar is defined below in the hasSlicing!Source section
static if (hasSlicing!Source)
{
/**
Indexing, slicing and bidirectional operations and range primitives.
Provided only if `hasSlicing!Source` is `true`.
*/
auto opIndex(size_t index)
{
assert(index < _chunkCount, "evenChunks index out of bounds");
return _source[_chunkPos(index) .. _chunkPos(index+1)];
}
/// Ditto
typeof(this) opSlice(size_t lower, size_t upper)
{
assert(lower <= upper && upper <= length, "evenChunks slicing index out of bounds");
return evenChunks(_source[_chunkPos(lower) .. _chunkPos(upper)], upper - lower);
}
/// Ditto
@property auto back()
{
assert(!empty, "back called on empty evenChunks");
return _source[_chunkPos(_chunkCount - 1) .. _source.length];
}
/// Ditto
void popBack()
{
assert(!empty, "popBack() called on empty evenChunks");
_source = _source[0 .. _chunkPos(_chunkCount - 1)];
_chunkCount--;
}
}
private:
Source _source;
size_t _chunkCount;
size_t _chunkPos(size_t i)
{
/*
_chunkCount = 5, _source.length = 13:
chunk0
| chunk3
| |
v v
+-+-+-+-+-+ ^
|0|3|.| | | |
+-+-+-+-+-+ | div
|1|4|.| | | |
+-+-+-+-+-+ v
|2|5|.|
+-+-+-+
<----->
mod
<--------->
_chunkCount
One column is one chunk.
popFront and popBack pop the left-most
and right-most column, respectively.
*/
auto div = _source.length / _chunkCount;
auto mod = _source.length % _chunkCount;
auto pos = i <= mod
? i * (div+1)
: mod * (div+1) + (i-mod) * div
;
//auto len = i < mod
// ? div+1
// : div
//;
return pos;
}
}
/// Ditto
EvenChunks!Source evenChunks(Source)(Source source, size_t chunkCount)
if (isForwardRange!Source && hasLength!Source)
{
return typeof(return)(source, chunkCount);
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
auto source = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
auto chunks = evenChunks(source, 3);
assert(chunks[0] == [1, 2, 3, 4]);
assert(chunks[1] == [5, 6, 7]);
assert(chunks[2] == [8, 9, 10]);
}
@safe unittest
{
import std.algorithm.comparison : equal;
auto source = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
auto chunks = evenChunks(source, 3);
assert(chunks.back == chunks[2]);
assert(chunks.front == chunks[0]);
assert(chunks.length == 3);
assert(equal(retro(array(chunks)), array(retro(chunks))));
auto chunks2 = chunks.save;
chunks.popFront();
assert(chunks[0] == [5, 6, 7]);
assert(chunks[1] == [8, 9, 10]);
chunks2.popBack();
assert(chunks2[1] == [5, 6, 7]);
assert(chunks2.length == 2);
static assert(isRandomAccessRange!(typeof(chunks)));
}
@safe unittest
{
import std.algorithm.comparison : equal;
int[] source = [];
auto chunks = source.evenChunks(0);
assert(chunks.length == 0);
chunks = source.evenChunks(3);
assert(equal(chunks, [[], [], []]));
chunks = [1, 2, 3].evenChunks(5);
assert(equal(chunks, [[1], [2], [3], [], []]));
}
/**
A fixed-sized sliding window iteration
of size `windowSize` over a `source` range by a custom `stepSize`.
The `Source` range must be at least a $(REF_ALTTEXT ForwardRange, isForwardRange, std,range,primitives)
and the `windowSize` must be greater than zero.
For `windowSize = 1` it splits the range into single element groups (aka `unflatten`)
For `windowSize = 2` it is similar to `zip(source, source.save.dropOne)`.
Params:
f = Whether the last element has fewer elements than `windowSize`
it should be be ignored (`No.withPartial`) or added (`Yes.withPartial`)
source = Range from which the slide will be selected
windowSize = Sliding window size
stepSize = Steps between the windows (by default 1)
Returns: Range of all sliding windows with propagated bi-directionality,
forwarding, random access, and slicing.
Note: To avoid performance overhead, $(REF_ALTTEXT bi-directionality, isBidirectionalRange, std,range,primitives)
is only available when $(REF hasSlicing, std,range,primitives)
and $(REF hasLength, std,range,primitives) are true.
See_Also: $(LREF chunks)
*/
auto slide(Flag!"withPartial" f = Yes.withPartial,
Source)(Source source, size_t windowSize, size_t stepSize = 1)
if (isForwardRange!Source)
{
return Slides!(f, Source)(source, windowSize, stepSize);
}
/// Iterate over ranges with windows
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
assert([0, 1, 2, 3].slide(2).equal!equal(
[[0, 1], [1, 2], [2, 3]]
));
assert(5.iota.slide(3).equal!equal(
[[0, 1, 2], [1, 2, 3], [2, 3, 4]]
));
}
/// set a custom stepsize (default 1)
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
assert(6.iota.slide(1, 2).equal!equal(
[[0], [2], [4]]
));
assert(6.iota.slide(2, 4).equal!equal(
[[0, 1], [4, 5]]
));
assert(iota(7).slide(2, 2).equal!equal(
[[0, 1], [2, 3], [4, 5], [6]]
));
assert(iota(12).slide(2, 4).equal!equal(
[[0, 1], [4, 5], [8, 9]]
));
}
/// Allow the last slide to have fewer elements than windowSize
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
assert(3.iota.slide!(No.withPartial)(4).empty);
assert(3.iota.slide!(Yes.withPartial)(4).equal!equal(
[[0, 1, 2]]
));
}
/// Count all the possible substrings of length 2
@safe pure nothrow unittest
{
import std.algorithm.iteration : each;
int[dstring] d;
"AGAGA"d.slide!(Yes.withPartial)(2).each!(a => d[a]++);
assert(d == ["AG"d: 2, "GA"d: 2]);
}
/// withPartial only has an effect if last element in the range doesn't have the full size
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
assert(5.iota.slide!(Yes.withPartial)(3, 4).equal!equal([[0, 1, 2], [4]]));
assert(6.iota.slide!(Yes.withPartial)(3, 4).equal!equal([[0, 1, 2], [4, 5]]));
assert(7.iota.slide!(Yes.withPartial)(3, 4).equal!equal([[0, 1, 2], [4, 5, 6]]));
assert(5.iota.slide!(No.withPartial)(3, 4).equal!equal([[0, 1, 2]]));
assert(6.iota.slide!(No.withPartial)(3, 4).equal!equal([[0, 1, 2]]));
assert(7.iota.slide!(No.withPartial)(3, 4).equal!equal([[0, 1, 2], [4, 5, 6]]));
}
private struct Slides(Flag!"withPartial" withPartial = Yes.withPartial, Source)
if (isForwardRange!Source)
{
private:
Source source;
size_t windowSize;
size_t stepSize;
static if (hasLength!Source)
{
enum needsEndTracker = false;
}
else
{
// If there's no information about the length, track needs to be kept manually
Source nextSource;
enum needsEndTracker = true;
}
bool _empty;
static if (hasSlicing!Source)
enum hasSliceToEnd = hasSlicing!Source && is(typeof(Source.init[0 .. $]) == Source);
static if (withPartial)
bool hasShownPartialBefore;
public:
/// Standard constructor
this(Source source, size_t windowSize, size_t stepSize)
{
assert(windowSize > 0, "windowSize must be greater than zero");
assert(stepSize > 0, "stepSize must be greater than zero");
this.source = source;
this.windowSize = windowSize;
this.stepSize = stepSize;
static if (needsEndTracker)
{
// `nextSource` is used to "look one step into the future" and check for the end
// this means `nextSource` is advanced by `stepSize` on every `popFront`
nextSource = source.save.drop(windowSize);
}
if (source.empty)
{
_empty = true;
return;
}
static if (withPartial)
{
static if (needsEndTracker)
{
if (nextSource.empty)
hasShownPartialBefore = true;
}
else
{
if (source.length <= windowSize)
hasShownPartialBefore = true;
}
}
else
{
// empty source range is needed, s.t. length, slicing etc. works properly
static if (needsEndTracker)
{
if (nextSource.empty)
_empty = true;
}
else
{
if (source.length < windowSize)
_empty = true;
}
}
}
/// Forward range primitives. Always present.
@property auto front()
{
assert(!empty, "Attempting to access front on an empty slide.");
static if (hasSlicing!Source && hasLength!Source)
{
static if (withPartial)
{
import std.algorithm.comparison : min;
return source[0 .. min(windowSize, source.length)];
}
else
{
assert(windowSize <= source.length, "The last element is smaller than the current windowSize.");
return source[0 .. windowSize];
}
}
else
{
static if (withPartial)
return source.save.take(windowSize);
else
return source.save.takeExactly(windowSize);
}
}
/// Ditto
void popFront()
{
assert(!empty, "Attempting to call popFront() on an empty slide.");
source.popFrontN(stepSize);
if (source.empty)
{
_empty = true;
return;
}
static if (withPartial)
{
if (hasShownPartialBefore)
_empty = true;
}
static if (needsEndTracker)
{
// Check the upcoming slide
auto poppedElements = nextSource.popFrontN(stepSize);
static if (withPartial)
{
if (poppedElements < stepSize || nextSource.empty)
hasShownPartialBefore = true;
}
else
{
if (poppedElements < stepSize)
_empty = true;
}
}
else
{
static if (withPartial)
{
if (source.length <= windowSize)
hasShownPartialBefore = true;
}
else
{
if (source.length < windowSize)
_empty = true;
}
}
}
static if (!isInfinite!Source)
{
/// Ditto
@property bool empty() const
{
return _empty;
}
}
else
{
// undocumented
enum empty = false;
}
/// Ditto
@property typeof(this) save()
{
return typeof(this)(source.save, windowSize, stepSize);
}
static if (hasLength!Source)
{
// gaps between the last element and the end of the range
private size_t gap()
{
/*
* Note:
* - In the following `end` is the exclusive end as used in opSlice
* - For the trivial case with `stepSize = 1` `end` is at `len`:
*
* iota(4).slide(2) = [[0, 1], [1, 2], [2, 3]] (end = 4)
* iota(4).slide(3) = [[0, 1, 2], [1, 2, 3]] (end = 4)
*
* - For the non-trivial cases, we need to calculate the gap
* between `len` and `end` - this is the number of missing elements
* from the input range:
*
* iota(7).slide(2, 3) = [[0, 1], [3, 4]] || <gap: 2> 6
* iota(7).slide(2, 4) = [[0, 1], [4, 5]] || <gap: 1> 6
* iota(7).slide(1, 5) = [[0], [5]] || <gap: 1> 6
*
* As it can be seen `gap` can be at most `stepSize - 1`
* More generally the elements of the sliding window with
* `w = windowSize` and `s = stepSize` are:
*
* [0, w], [s, s + w], [2 * s, 2 * s + w], ... [n * s, n * s + w]
*
* We can thus calculate the gap between the `end` and `len` as:
*
* gap = len - (n * s + w) = len - w - (n * s)
*
* As we aren't interested in exact value of `n`, but the best
* minimal `gap` value, we can use modulo to "cut" `len - w` optimally:
*
* gap = len - w - (s - s ... - s) = (len - w) % s
*
* So for example:
*
* iota(7).slide(2, 3) = [[0, 1], [3, 4]]
* gap: (7 - 2) % 3 = 5 % 3 = 2
* end: 7 - 2 = 5
*
* iota(7).slide(4, 2) = [[0, 1, 2, 3], [2, 3, 4, 5]]
* gap: (7 - 4) % 2 = 3 % 2 = 1
* end: 7 - 1 = 6
*/
return (source.length - windowSize) % stepSize;
}
private size_t numberOfFullFrames()
{
/**
5.iota.slides(2, 1) => [0, 1], [1, 2], [2, 3], [3, 4] (4)
7.iota.slides(2, 2) => [0, 1], [2, 3], [4, 5], [6] (3)
7.iota.slides(2, 3) => [0, 1], [3, 4], [6] (2)
6.iota.slides(3, 2) => [0, 1, 2], [2, 3, 4], [4, 5] (2)
7.iota.slides(3, 3) => [0, 1, 2], [3, 4, 5], [6] (2)
As the last window is only added iff its complete,
we don't count the last window except if it's full due to integer rounding.
*/
return 1 + (source.length - windowSize) / stepSize;
}
// Whether the last slide frame size is less than windowSize
private bool hasPartialElements()
{
static if (withPartial)
return gap != 0 && source.length > numberOfFullFrames * stepSize;
else
return 0;
}
/// Length. Only if `hasLength!Source` is `true`
@property size_t length()
{
if (source.length < windowSize)
{
static if (withPartial)
return source.length > 0;
else
return 0;
}
else
{
/***
We bump the pointer by stepSize for every element.
If withPartial, we don't count the last element if its size
isn't windowSize
At most:
[p, p + stepSize, ..., p + stepSize * n]
5.iota.slides(2, 1) => [0, 1], [1, 2], [2, 3], [3, 4] (4)
7.iota.slides(2, 2) => [0, 1], [2, 3], [4, 5], [6] (4)
7.iota.slides(2, 3) => [0, 1], [3, 4], [6] (3)
7.iota.slides(3, 2) => [0, 1, 2], [2, 3, 4], [4, 5, 6] (3)
7.iota.slides(3, 3) => [0, 1, 2], [3, 4, 5], [6] (3)
*/
return numberOfFullFrames + hasPartialElements;
}
}
}
static if (hasSlicing!Source)
{
/**
Indexing and slicing operations. Provided only if
`hasSlicing!Source` is `true`.
*/
auto opIndex(size_t index)
{
immutable start = index * stepSize;
static if (isInfinite!Source)
{
immutable end = start + windowSize;
}
else
{
import std.algorithm.comparison : min;
immutable len = source.length;
assert(start < len, "slide index out of bounds");
immutable end = min(start + windowSize, len);
}
return source[start .. end];
}
static if (!isInfinite!Source)
{
/// ditto
typeof(this) opSlice(size_t lower, size_t upper)
{
import std.algorithm.comparison : min;
assert(upper <= length, "slide slicing index out of bounds");
assert(lower <= upper, "slide slicing index out of bounds");
lower *= stepSize;
upper *= stepSize;
immutable len = source.length;
static if (withPartial)
{
import std.algorithm.comparison : max;
if (lower == upper)
return this[$ .. $];
/*
A) If `stepSize` >= `windowSize` => `rightPos = upper`
[0, 1, 2, 3, 4, 5, 6].slide(2, 3) -> s = [[0, 1], [3, 4], [6]]
rightPos for s[0 .. 2]: (upper=2) * (stepSize=3) = 6
6.iota.slide(2, 3) = [[0, 1], [3, 4]]
B) If `stepSize` < `windowSize` => add `windowSize - stepSize` to `upper`
[0, 1, 2, 3].slide(2) = [[0, 1], [1, 2], [2, 3]]
rightPos for s[0 .. 1]: = (upper=1) * (stepSize=1) = 1
1.iota.slide(2) = [[0]]
rightPos for s[0 .. 1]: = (upper=1) * (stepSize=1) + (windowSize-stepSize=1) = 2
1.iota.slide(2) = [[0, 1]]
More complex:
20.iota.slide(7, 6)[0 .. 2]
rightPos: (upper=2) * (stepSize=6) = 12.iota
12.iota.slide(7, 6) = [[0, 1, 2, 3, 4, 5, 6], [6, 7, 8, 9, 10, 11]]
Now we add up for the difference between `windowSize` and `stepSize`:
rightPos: (upper=2) * (stepSize=6) + (windowSize-stepSize=1) = 13.iota
13.iota.slide(7, 6) = [[0, 1, 2, 3, 4, 5, 6], [6, 7, 8, 9, 10, 11, 12]]
*/
immutable rightPos = min(len, upper + max(0, windowSize - stepSize));
}
else
{
/*
After we have normalized `lower` and `upper` by `stepSize`,
we only need to look at the case of `stepSize=1`.
As `leftPos`, is equal to `lower`, we will only look `rightPos`.
Notice that starting from `upper`,
we only need to move for `windowSize - 1` to the right:
- [0, 1, 2, 3].slide(2) -> s = [[0, 1], [1, 2], [2, 3]]
rightPos for s[0 .. 3]: (upper=3) + (windowSize=2) - 1 = 4
- [0, 1, 2, 3].slide(3) -> s = [[0, 1, 2], [1, 2, 3]]
rightPos for s[0 .. 2]: (upper=2) + (windowSize=3) - 1 = 4
- [0, 1, 2, 3, 4].slide(4) -> s = [[0, 1, 2, 3], [1, 2, 3, 4]]
rightPos for s[0 .. 2]: (upper=2) + (windowSize=4) - 1 = 5
*/
immutable rightPos = min(upper + windowSize - 1, len);
}
return typeof(this)(source[min(lower, len) .. rightPos], windowSize, stepSize);
}
}
else static if (hasSliceToEnd)
{
// For slicing an infinite chunk, we need to slice the source to the infinite end.
auto opSlice(size_t lower, size_t upper)
{
assert(lower <= upper, "slide slicing index out of bounds");
return typeof(this)(source[lower * stepSize .. $], windowSize, stepSize)
.takeExactly(upper - lower);
}
}
static if (isInfinite!Source)
{
static if (hasSliceToEnd)
{
private static struct DollarToken{}
DollarToken opDollar()
{
return DollarToken();
}
//Slice to dollar
typeof(this) opSlice(size_t lower, DollarToken)
{
return typeof(this)(source[lower * stepSize .. $], windowSize, stepSize);
}
}
}
else
{
// Dollar token carries a static type, with no extra information.
// It can lazily transform into source.length on algorithmic
// operations such as : slide[$/2, $-1];
private static struct DollarToken
{
private size_t _length;
alias _length this;
}
DollarToken opDollar()
{
return DollarToken(this.length);
}
// Optimized slice overloads optimized for using dollar.
typeof(this) opSlice(DollarToken, DollarToken)
{
static if (hasSliceToEnd)
{
return typeof(this)(source[$ .. $], windowSize, stepSize);
}
else
{
immutable len = source.length;
return typeof(this)(source[len .. len], windowSize, stepSize);
}
}
// Optimized slice overloads optimized for using dollar.
typeof(this) opSlice(size_t lower, DollarToken)
{
import std.algorithm.comparison : min;
assert(lower <= length, "slide slicing index out of bounds");
lower *= stepSize;
static if (hasSliceToEnd)
{
return typeof(this)(source[min(lower, source.length) .. $], windowSize, stepSize);
}
else
{
immutable len = source.length;
return typeof(this)(source[min(lower, len) .. len], windowSize, stepSize);
}
}
// Optimized slice overloads optimized for using dollar.
typeof(this) opSlice(DollarToken, size_t upper)
{
assert(upper == length, "slide slicing index out of bounds");
return this[$ .. $];
}
}
// Bidirectional range primitives
static if (!isInfinite!Source)
{
/**
Bidirectional range primitives. Provided only if both
`hasSlicing!Source` and `!isInfinite!Source` are `true`.
*/
@property auto back()
{
import std.algorithm.comparison : max;
assert(!empty, "Attempting to access front on an empty slide");
immutable len = source.length;
static if (withPartial)
{
if (source.length <= windowSize)
return source[0 .. source.length];
if (hasPartialElements)
return source[numberOfFullFrames * stepSize .. len];
}
// check for underflow
immutable start = (len > windowSize + gap) ? len - windowSize - gap : 0;
return source[start .. len - gap];
}
/// Ditto
void popBack()
{
assert(!empty, "Attempting to call popBack() on an empty slide");
// Move by stepSize
immutable end = source.length > stepSize ? source.length - stepSize : 0;
static if (withPartial)
{
if (hasShownPartialBefore || source.empty)
{
_empty = true;
return;
}
// pop by stepSize, except for the partial frame at the end
if (hasPartialElements)
source = source[0 .. source.length - gap];
else
source = source[0 .. end];
}
else
{
source = source[0 .. end];
}
if (source.length < windowSize)
_empty = true;
}
}
}
}
// test @nogc
@safe pure nothrow @nogc unittest
{
import std.algorithm.comparison : equal;
static immutable res1 = [[0], [1], [2], [3]];
assert(4.iota.slide!(Yes.withPartial)(1).equal!equal(res1));
static immutable res2 = [[0, 1], [1, 2], [2, 3]];
assert(4.iota.slide!(Yes.withPartial)(2).equal!equal(res2));
}
// test different window sizes
@safe pure nothrow unittest
{
import std.array : array;
import std.algorithm.comparison : equal;
assert([0, 1, 2, 3].slide!(Yes.withPartial)(1).array == [[0], [1], [2], [3]]);
assert([0, 1, 2, 3].slide!(Yes.withPartial)(2).array == [[0, 1], [1, 2], [2, 3]]);
assert([0, 1, 2, 3].slide!(Yes.withPartial)(3).array == [[0, 1, 2], [1, 2, 3]]);
assert([0, 1, 2, 3].slide!(Yes.withPartial)(4).array == [[0, 1, 2, 3]]);
assert([0, 1, 2, 3].slide!(No.withPartial)(5).walkLength == 0);
assert([0, 1, 2, 3].slide!(Yes.withPartial)(5).array == [[0, 1, 2, 3]]);
assert(iota(2).slide!(Yes.withPartial)(2).front.equal([0, 1]));
assert(iota(3).slide!(Yes.withPartial)(2).equal!equal([[0, 1],[1, 2]]));
assert(iota(3).slide!(Yes.withPartial)(3).equal!equal([[0, 1, 2]]));
assert(iota(3).slide!(No.withPartial)(4).walkLength == 0);
assert(iota(3).slide!(Yes.withPartial)(4).equal!equal([[0, 1, 2]]));
assert(iota(1, 4).slide!(Yes.withPartial)(1).equal!equal([[1], [2], [3]]));
assert(iota(1, 4).slide!(Yes.withPartial)(3).equal!equal([[1, 2, 3]]));
}
// test combinations
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
import std.typecons : tuple;
alias t = tuple;
auto list = [
t(t(1, 1), [[0], [1], [2], [3], [4], [5]]),
t(t(1, 2), [[0], [2], [4]]),
t(t(1, 3), [[0], [3]]),
t(t(1, 4), [[0], [4]]),
t(t(1, 5), [[0], [5]]),
t(t(2, 1), [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]]),
t(t(2, 2), [[0, 1], [2, 3], [4, 5]]),
t(t(2, 3), [[0, 1], [3, 4]]),
t(t(2, 4), [[0, 1], [4, 5]]),
t(t(3, 1), [[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5]]),
t(t(3, 3), [[0, 1, 2], [3, 4, 5]]),
t(t(4, 1), [[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]),
t(t(4, 2), [[0, 1, 2, 3], [2, 3, 4, 5]]),
t(t(5, 1), [[0, 1, 2, 3, 4], [1, 2, 3, 4, 5]]),
];
static foreach (Partial; [Yes.withPartial, No.withPartial])
foreach (e; list)
assert(6.iota.slide!Partial(e[0].expand).equal!equal(e[1]));
auto listSpecial = [
t(t(2, 5), [[0, 1], [5]]),
t(t(3, 2), [[0, 1, 2], [2, 3, 4], [4, 5]]),
t(t(3, 4), [[0, 1, 2], [4, 5]]),
t(t(4, 3), [[0, 1, 2, 3], [3, 4, 5]]),
t(t(5, 2), [[0, 1, 2, 3, 4], [2, 3, 4, 5]]),
t(t(5, 3), [[0, 1, 2, 3, 4], [3, 4, 5]]),
];
foreach (e; listSpecial)
{
assert(6.iota.slide!(Yes.withPartial)(e[0].expand).equal!equal(e[1]));
assert(6.iota.slide!(No.withPartial)(e[0].expand).equal!equal(e[1].dropBackOne));
}
}
// test emptiness and copyability
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : map;
// check with empty input
int[] d;
assert(d.slide!(Yes.withPartial)(2).empty);
assert(d.slide!(Yes.withPartial)(2, 2).empty);
// is copyable?
auto e = iota(5).slide!(Yes.withPartial)(2);
e.popFront;
assert(e.save.equal!equal([[1, 2], [2, 3], [3, 4]]));
assert(e.save.equal!equal([[1, 2], [2, 3], [3, 4]]));
assert(e.map!"a.array".array == [[1, 2], [2, 3], [3, 4]]);
}
// test with strings
@safe pure nothrow unittest
{
import std.algorithm.iteration : each;
int[dstring] f;
"AGAGA"d.slide!(Yes.withPartial)(3).each!(a => f[a]++);
assert(f == ["AGA"d: 2, "GAG"d: 1]);
int[dstring] g;
"ABCDEFG"d.slide!(Yes.withPartial)(3, 3).each!(a => g[a]++);
assert(g == ["ABC"d:1, "DEF"d:1, "G": 1]);
g = null;
"ABCDEFG"d.slide!(No.withPartial)(3, 3).each!(a => g[a]++);
assert(g == ["ABC"d:1, "DEF"d:1]);
}
// test with utf8 strings
@safe unittest
{
import std.stdio;
import std.algorithm.comparison : equal;
assert("ä.ö.ü.".slide!(Yes.withPartial)(3, 2).equal!equal(["ä.ö", "ö.ü", "ü."]));
assert("ä.ö.ü.".slide!(No.withPartial)(3, 2).equal!equal(["ä.ö", "ö.ü"]));
"😄😅😆😇😈😄😅😆😇😈".slide!(Yes.withPartial)(2, 4).equal!equal(["😄😅", "😈😄", "😇😈"]);
"😄😅😆😇😈😄😅😆😇😈".slide!(No.withPartial)(2, 4).equal!equal(["😄😅", "😈😄", "😇😈"]);
"😄😅😆😇😈😄😅😆😇😈".slide!(Yes.withPartial)(3, 3).equal!equal(["😄😅😆", "😇😈😄", "😅😆😇", "😈"]);
"😄😅😆😇😈😄😅😆😇😈".slide!(No.withPartial)(3, 3).equal!equal(["😄😅😆", "😇😈😄", "😅😆😇"]);
}
// test length
@safe pure nothrow unittest
{
// Slides with fewer elements are empty or 1 for Yes.withPartial
static foreach (expectedLength, Partial; [No.withPartial, Yes.withPartial])
{{
assert(3.iota.slide!(Partial)(4, 2).walkLength == expectedLength);
assert(3.iota.slide!(Partial)(4).walkLength == expectedLength);
assert(3.iota.slide!(Partial)(4, 3).walkLength == expectedLength);
}}
static immutable list = [
// iota slide expected
[4, 2, 1, 3, 3],
[5, 3, 1, 3, 3],
[7, 2, 2, 4, 3],
[12, 2, 4, 3, 3],
[6, 1, 2, 3, 3],
[6, 2, 4, 2, 2],
[3, 2, 4, 1, 1],
[5, 2, 1, 4, 4],
[7, 2, 2, 4, 3],
[7, 2, 3, 3, 2],
[7, 3, 2, 3, 3],
[7, 3, 3, 3, 2],
];
foreach (e; list)
{
assert(e[0].iota.slide!(Yes.withPartial)(e[1], e[2]).length == e[3]);
assert(e[0].iota.slide!(No.withPartial)(e[1], e[2]).length == e[4]);
}
}
// test index and slicing
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
import std.array : array;
static foreach (Partial; [Yes.withPartial, No.withPartial])
{
foreach (s; [5, 7, 10, 15, 20])
foreach (windowSize; 1 .. 10)
foreach (stepSize; 1 .. 10)
{
auto r = s.iota.slide!Partial(windowSize, stepSize);
auto arr = r.array;
assert(r.length == arr.length);
// test indexing
foreach (i; 0 .. arr.length)
assert(r[i] == arr[i]);
// test slicing
foreach (i; 0 .. arr.length)
{
foreach (j; i .. arr.length)
assert(r[i .. j].equal(arr[i .. j]));
assert(r[i .. $].equal(arr[i .. $]));
}
// test opDollar slicing
assert(r[$/2 .. $].equal(arr[$/2 .. $]));
assert(r[$ .. $].empty);
if (arr.empty)
{
assert(r[$ .. 0].empty);
assert(r[$/2 .. $].empty);
}
}
}
}
// test with infinite ranges
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
static foreach (Partial; [Yes.withPartial, No.withPartial])
{{
// InfiniteRange without RandomAccess
auto fibs = recurrence!"a[n-1] + a[n-2]"(1, 1);
assert(fibs.slide!Partial(2).take(2).equal!equal([[1, 1], [1, 2]]));
assert(fibs.slide!Partial(2, 3).take(2).equal!equal([[1, 1], [3, 5]]));
// InfiniteRange with RandomAccess and slicing
auto odds = sequence!("a[0] + n * a[1]")(1, 2);
auto oddsByPairs = odds.slide!Partial(2);
assert(oddsByPairs.take(2).equal!equal([[ 1, 3], [ 3, 5]]));
assert(oddsByPairs[1].equal([3, 5]));
assert(oddsByPairs[4].equal([9, 11]));
static assert(hasSlicing!(typeof(odds)));
assert(oddsByPairs[3 .. 5].equal!equal([[7, 9], [9, 11]]));
assert(oddsByPairs[3 .. $].take(2).equal!equal([[7, 9], [9, 11]]));
auto oddsWithGaps = odds.slide!Partial(2, 4);
assert(oddsWithGaps.take(3).equal!equal([[1, 3], [9, 11], [17, 19]]));
assert(oddsWithGaps[2].equal([17, 19]));
assert(oddsWithGaps[1 .. 3].equal!equal([[9, 11], [17, 19]]));
assert(oddsWithGaps[1 .. $].take(2).equal!equal([[9, 11], [17, 19]]));
}}
}
// test reverse
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
static foreach (Partial; [Yes.withPartial, No.withPartial])
{{
foreach (windowSize; 1 .. 15)
foreach (stepSize; 1 .. 15)
{
auto r = 20.iota.slide!Partial(windowSize, stepSize);
auto rArr = r.array.retro;
auto rRetro = r.retro;
assert(rRetro.length == rArr.length);
assert(rRetro.equal(rArr));
assert(rRetro.array.retro.equal(r));
}
}}
}
// test with dummy ranges
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges;
import std.meta : Filter;
static foreach (Range; Filter!(isForwardRange, AllDummyRanges))
{{
Range r;
static foreach (Partial; [Yes.withPartial, No.withPartial])
{
assert(r.slide!Partial(1).equal!equal(
[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]]
));
assert(r.slide!Partial(2).equal!equal(
[[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 10]]
));
assert(r.slide!Partial(3).equal!equal(
[[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6],
[5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10]]
));
assert(r.slide!Partial(6).equal!equal(
[[1, 2, 3, 4, 5, 6], [2, 3, 4, 5, 6, 7], [3, 4, 5, 6, 7, 8],
[4, 5, 6, 7, 8, 9], [5, 6, 7, 8, 9, 10]]
));
}
// special cases
assert(r.slide!(Yes.withPartial)(15).equal!equal(iota(1, 11).only));
assert(r.slide!(Yes.withPartial)(15).walkLength == 1);
assert(r.slide!(No.withPartial)(15).empty);
assert(r.slide!(No.withPartial)(15).walkLength == 0);
}}
}
// test with dummy ranges
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges;
import std.meta : Filter;
import std.typecons : tuple;
alias t = tuple;
static immutable list = [
// iota slide expected
t(6, t(4, 2), [[1, 2, 3, 4], [3, 4, 5, 6]]),
t(6, t(4, 6), [[1, 2, 3, 4]]),
t(6, t(4, 1), [[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6]]),
t(7, t(4, 1), [[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7]]),
t(7, t(4, 3), [[1, 2, 3, 4], [4, 5, 6, 7]]),
t(8, t(4, 2), [[1, 2, 3, 4], [3, 4, 5, 6], [5, 6, 7, 8]]),
t(8, t(4, 1), [[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8]]),
t(8, t(3, 4), [[1, 2, 3], [5, 6, 7]]),
t(10, t(3, 7), [[1, 2, 3], [8, 9, 10]]),
];
static foreach (Range; Filter!(isForwardRange, AllDummyRanges))
static foreach (Partial; [Yes.withPartial, No.withPartial])
foreach (e; list)
assert(Range().take(e[0]).slide!Partial(e[1].expand).equal!equal(e[2]));
static immutable listSpecial = [
// iota slide expected
t(6, t(4, 3), [[1, 2, 3, 4], [4, 5, 6]]),
t(7, t(4, 5), [[1, 2, 3, 4], [6, 7]]),
t(7, t(4, 4), [[1, 2, 3, 4], [5, 6, 7]]),
t(7, t(4, 2), [[1, 2, 3, 4], [3, 4, 5, 6], [5, 6, 7]]),
t(8, t(4, 3), [[1, 2, 3, 4], [4, 5, 6, 7], [7, 8]]),
t(8, t(3, 3), [[1, 2, 3], [4, 5, 6], [7, 8]]),
t(8, t(3, 6), [[1, 2, 3], [7, 8]]),
t(10, t(7, 6), [[1, 2, 3, 4, 5, 6, 7], [7, 8, 9, 10]]),
t(10, t(3, 8), [[1, 2, 3], [9, 10]]),
];
static foreach (Range; Filter!(isForwardRange, AllDummyRanges))
static foreach (Partial; [Yes.withPartial, No.withPartial])
foreach (e; listSpecial)
{
Range r;
assert(r.take(e[0]).slide!(Yes.withPartial)(e[1].expand).equal!equal(e[2]));
assert(r.take(e[0]).slide!(No.withPartial)(e[1].expand).equal!equal(e[2].dropBackOne));
}
}
// test reverse with dummy ranges
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges;
import std.meta : Filter, templateAnd;
import std.typecons : tuple;
alias t = tuple;
static immutable list = [
// slide expected
t(1, 1, [[10], [9], [8], [7], [6], [5], [4], [3], [2], [1]]),
t(2, 1, [[9, 10], [8, 9], [7, 8], [6, 7], [5, 6], [4, 5], [3, 4], [2, 3], [1, 2]]),
t(5, 1, [[6, 7, 8, 9, 10], [5, 6, 7, 8, 9], [4, 5, 6, 7, 8],
[3, 4, 5, 6, 7], [2, 3, 4, 5, 6], [1, 2, 3, 4, 5]]),
t(2, 2, [[9, 10], [7, 8], [5, 6], [3, 4], [1, 2]]),
t(2, 4, [[9, 10], [5, 6], [1, 2]]),
];
static foreach (Range; Filter!(templateAnd!(hasSlicing, hasLength, isBidirectionalRange), AllDummyRanges))
{{
Range r;
static foreach (Partial; [Yes.withPartial, No.withPartial])
{
foreach (e; list)
assert(r.slide!Partial(e[0], e[1]).retro.equal!equal(e[2]));
// front = back
foreach (windowSize; 1 .. 10)
foreach (stepSize; 1 .. 10)
{
auto slider = r.slide!Partial(windowSize, stepSize);
auto sliderRetro = slider.retro.array;
assert(slider.length == sliderRetro.length);
assert(sliderRetro.retro.equal!equal(slider));
}
}
// special cases
assert(r.slide!(No.withPartial)(15).retro.walkLength == 0);
assert(r.slide!(Yes.withPartial)(15).retro.equal!equal(iota(1, 11).only));
}}
}
// test different sliceable ranges
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges;
import std.meta : AliasSeq;
struct SliceableRange(Range, Flag!"withOpDollar" withOpDollar = No.withOpDollar,
Flag!"withInfiniteness" withInfiniteness = No.withInfiniteness)
{
Range arr = 10.iota.array; // similar to DummyRange
@property auto save() { return typeof(this)(arr); }
@property auto front() { return arr[0]; }
void popFront() { arr.popFront(); }
auto opSlice(size_t i, size_t j)
{
// subslices can't be infinite
return SliceableRange!(Range, withOpDollar, No.withInfiniteness)(arr[i .. j]);
}
static if (withInfiniteness)
{
enum empty = false;
}
else
{
@property bool empty() { return arr.empty; }
@property auto length() { return arr.length; }
}
static if (withOpDollar)
{
static if (withInfiniteness)
{
struct Dollar {}
Dollar opDollar() const { return Dollar.init; }
// Slice to dollar
typeof(this) opSlice(size_t lower, Dollar)
{
return typeof(this)(arr[lower .. $]);
}
}
else
{
alias opDollar = length;
}
}
}
import std.meta : Filter, templateNot;
alias SliceableDummyRanges = Filter!(hasSlicing, AllDummyRanges);
static foreach (Partial; [Yes.withPartial, No.withPartial])
{{
static foreach (Range; SliceableDummyRanges)
{{
Range r;
r.reinit;
r.arr[] -= 1; // use a 0-based array (for clarity)
assert(r.slide!Partial(2)[0].equal([0, 1]));
assert(r.slide!Partial(2)[1].equal([1, 2]));
// saveable
auto s = r.slide!Partial(2);
assert(s[0 .. 2].equal!equal([[0, 1], [1, 2]]));
s.save.popFront;
assert(s[0 .. 2].equal!equal([[0, 1], [1, 2]]));
assert(r.slide!Partial(3)[1 .. 3].equal!equal([[1, 2, 3], [2, 3, 4]]));
}}
static foreach (Range; Filter!(templateNot!isInfinite, SliceableDummyRanges))
{{
Range r;
r.reinit;
r.arr[] -= 1; // use a 0-based array (for clarity)
assert(r.slide!(No.withPartial)(6).equal!equal(
[[0, 1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6], [2, 3, 4, 5, 6, 7],
[3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9]]
));
assert(r.slide!(No.withPartial)(16).empty);
assert(r.slide!Partial(4)[0 .. $].equal(r.slide!Partial(4)));
assert(r.slide!Partial(2)[$/2 .. $].equal!equal([[4, 5], [5, 6], [6, 7], [7, 8], [8, 9]]));
assert(r.slide!Partial(2)[$ .. $].empty);
assert(r.slide!Partial(3).retro.equal!equal(
[[7, 8, 9], [6, 7, 8], [5, 6, 7], [4, 5, 6], [3, 4, 5], [2, 3, 4], [1, 2, 3], [0, 1, 2]]
));
}}
alias T = int[];
// separate checks for infinity
auto infIndex = SliceableRange!(T, No.withOpDollar, Yes.withInfiniteness)([0, 1, 2, 3]);
assert(infIndex.slide!Partial(2)[0].equal([0, 1]));
assert(infIndex.slide!Partial(2)[1].equal([1, 2]));
auto infDollar = SliceableRange!(T, Yes.withOpDollar, Yes.withInfiniteness)();
assert(infDollar.slide!Partial(2)[1 .. $].front.equal([1, 2]));
assert(infDollar.slide!Partial(4)[0 .. $].front.equal([0, 1, 2, 3]));
assert(infDollar.slide!Partial(4)[2 .. $].front.equal([2, 3, 4, 5]));
}}
}
// https://issues.dlang.org/show_bug.cgi?id=19082
@safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : map;
assert([1].map!(x => x).slide(2).equal!equal([[1]]));
}
private struct OnlyResult(T, size_t arity)
{
private this(Values...)(return scope auto ref Values values)
{
this.data = [values];
this.backIndex = arity;
}
bool empty() @property
{
return frontIndex >= backIndex;
}
T front() @property
{
assert(!empty, "Attempting to fetch the front of an empty Only range");
return data[frontIndex];
}
void popFront()
{
assert(!empty, "Attempting to popFront an empty Only range");
++frontIndex;
}
T back() @property
{
assert(!empty, "Attempting to fetch the back of an empty Only range");
return data[backIndex - 1];
}
void popBack()
{
assert(!empty, "Attempting to popBack an empty Only range");
--backIndex;
}
OnlyResult save() @property
{
return this;
}
size_t length() const @property
{
return backIndex - frontIndex;
}
alias opDollar = length;
T opIndex(size_t idx)
{
// when i + idx points to elements popped
// with popBack
assert(idx < length, "Attempting to fetch an out of bounds index from an Only range");
return data[frontIndex + idx];
}
OnlyResult opSlice()
{
return this;
}
OnlyResult opSlice(size_t from, size_t to)
{
OnlyResult result = this;
result.frontIndex += from;
result.backIndex = this.frontIndex + to;
assert(
from <= to,
"Attempting to slice an Only range with a larger first argument than the second."
);
assert(
to <= length,
"Attempting to slice using an out of bounds index on an Only range"
);
return result;
}
private size_t frontIndex = 0;
private size_t backIndex = 0;
// @@@BUG@@@ 10643
version (none)
{
import std.traits : hasElaborateAssign;
static if (hasElaborateAssign!T)
private T[arity] data;
else
private T[arity] data = void;
}
else
private T[arity] data;
}
// Specialize for single-element results
private struct OnlyResult(T, size_t arity : 1)
{
@property T front()
{
assert(!empty, "Attempting to fetch the front of an empty Only range");
return _value;
}
@property T back()
{
assert(!empty, "Attempting to fetch the back of an empty Only range");
return _value;
}
@property bool empty() const { return _empty; }
@property size_t length() const { return !_empty; }
@property auto save() { return this; }
void popFront()
{
assert(!_empty, "Attempting to popFront an empty Only range");
_empty = true;
}
void popBack()
{
assert(!_empty, "Attempting to popBack an empty Only range");
_empty = true;
}
alias opDollar = length;
private this()(return scope auto ref T value)
{
this._value = value;
this._empty = false;
}
T opIndex(size_t i)
{
assert(!_empty && i == 0, "Attempting to fetch an out of bounds index from an Only range");
return _value;
}
OnlyResult opSlice()
{
return this;
}
OnlyResult opSlice(size_t from, size_t to)
{
assert(
from <= to,
"Attempting to slice an Only range with a larger first argument than the second."
);
assert(
to <= length,
"Attempting to slice using an out of bounds index on an Only range"
);
OnlyResult copy = this;
copy._empty = _empty || from == to;
return copy;
}
private Unqual!T _value;
private bool _empty = true;
}
// Specialize for the empty range
private struct OnlyResult(T, size_t arity : 0)
{
private static struct EmptyElementType {}
bool empty() @property { return true; }
size_t length() const @property { return 0; }
alias opDollar = length;
EmptyElementType front() @property { assert(false); }
void popFront() { assert(false); }
EmptyElementType back() @property { assert(false); }
void popBack() { assert(false); }
OnlyResult save() @property { return this; }
EmptyElementType opIndex(size_t i)
{
assert(false);
}
OnlyResult opSlice() { return this; }
OnlyResult opSlice(size_t from, size_t to)
{
assert(from == 0 && to == 0);
return this;
}
}
/**
Assemble `values` into a range that carries all its
elements in-situ.
Useful when a single value or multiple disconnected values
must be passed to an algorithm expecting a range, without
having to perform dynamic memory allocation.
As copying the range means copying all elements, it can be
safely returned from functions. For the same reason, copying
the returned range may be expensive for a large number of arguments.
Params:
values = the values to assemble together
Returns:
A `RandomAccessRange` of the assembled values.
See_Also: $(LREF chain) to chain ranges
*/
auto only(Values...)(return scope Values values)
if (!is(CommonType!Values == void) || Values.length == 0)
{
return OnlyResult!(CommonType!Values, Values.length)(values);
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filter, joiner, map;
import std.algorithm.searching : findSplitBefore;
import std.uni : isUpper;
assert(equal(only('♡'), "♡"));
assert([1, 2, 3, 4].findSplitBefore(only(3))[0] == [1, 2]);
assert(only("one", "two", "three").joiner(" ").equal("one two three"));
string title = "The D Programming Language";
assert(title
.filter!isUpper // take the upper case letters
.map!only // make each letter its own range
.joiner(".") // join the ranges together lazily
.equal("T.D.P.L"));
}
@safe unittest
{
// Verify that the same common type and same arity
// results in the same template instantiation
static assert(is(typeof(only(byte.init, int.init)) ==
typeof(only(int.init, byte.init))));
static assert(is(typeof(only((const(char)[]).init, string.init)) ==
typeof(only((const(char)[]).init, (const(char)[]).init))));
}
// https://issues.dlang.org/show_bug.cgi?id=20314
@safe unittest
{
import std.algorithm.iteration : joiner;
const string s = "foo", t = "bar";
assert([only(s, t), only(t, s)].joiner(only(", ")).join == "foobar, barfoo");
}
// Tests the zero-element result
@safe unittest
{
import std.algorithm.comparison : equal;
auto emptyRange = only();
alias EmptyRange = typeof(emptyRange);
static assert(isInputRange!EmptyRange);
static assert(isForwardRange!EmptyRange);
static assert(isBidirectionalRange!EmptyRange);
static assert(isRandomAccessRange!EmptyRange);
static assert(hasLength!EmptyRange);
static assert(hasSlicing!EmptyRange);
assert(emptyRange.empty);
assert(emptyRange.length == 0);
assert(emptyRange.equal(emptyRange[]));
assert(emptyRange.equal(emptyRange.save));
assert(emptyRange[0 .. 0].equal(emptyRange));
}
// Tests the single-element result
@safe unittest
{
import std.algorithm.comparison : equal;
import std.typecons : tuple;
foreach (x; tuple(1, '1', 1.0, "1", [1]))
{
auto a = only(x);
typeof(x)[] e = [];
assert(a.front == x);
assert(a.back == x);
assert(!a.empty);
assert(a.length == 1);
assert(equal(a, a[]));
assert(equal(a, a[0 .. 1]));
assert(equal(a[0 .. 0], e));
assert(equal(a[1 .. 1], e));
assert(a[0] == x);
auto b = a.save;
assert(equal(a, b));
a.popFront();
assert(a.empty && a.length == 0 && a[].empty);
b.popBack();
assert(b.empty && b.length == 0 && b[].empty);
alias A = typeof(a);
static assert(isInputRange!A);
static assert(isForwardRange!A);
static assert(isBidirectionalRange!A);
static assert(isRandomAccessRange!A);
static assert(hasLength!A);
static assert(hasSlicing!A);
}
auto imm = only!(immutable int)(1);
immutable int[] imme = [];
assert(imm.front == 1);
assert(imm.back == 1);
assert(!imm.empty);
assert(imm.init.empty); // Issue 13441
assert(imm.length == 1);
assert(equal(imm, imm[]));
assert(equal(imm, imm[0 .. 1]));
assert(equal(imm[0 .. 0], imme));
assert(equal(imm[1 .. 1], imme));
assert(imm[0] == 1);
}
// Tests multiple-element results
@safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : joiner;
import std.meta : AliasSeq;
static assert(!__traits(compiles, only(1, "1")));
auto nums = only!(byte, uint, long)(1, 2, 3);
static assert(is(ElementType!(typeof(nums)) == long));
assert(nums.length == 3);
foreach (i; 0 .. 3)
assert(nums[i] == i + 1);
auto saved = nums.save;
foreach (i; 1 .. 4)
{
assert(nums.front == nums[0]);
assert(nums.front == i);
nums.popFront();
assert(nums.length == 3 - i);
}
assert(nums.empty);
assert(saved.equal(only(1, 2, 3)));
assert(saved.equal(saved[]));
assert(saved[0 .. 1].equal(only(1)));
assert(saved[0 .. 2].equal(only(1, 2)));
assert(saved[0 .. 3].equal(saved));
assert(saved[1 .. 3].equal(only(2, 3)));
assert(saved[2 .. 3].equal(only(3)));
assert(saved[0 .. 0].empty);
assert(saved[3 .. 3].empty);
alias data = AliasSeq!("one", "two", "three", "four");
static joined =
["one two", "one two three", "one two three four"];
string[] joinedRange = joined;
static foreach (argCount; 2 .. 5)
{{
auto values = only(data[0 .. argCount]);
alias Values = typeof(values);
static assert(is(ElementType!Values == string));
static assert(isInputRange!Values);
static assert(isForwardRange!Values);
static assert(isBidirectionalRange!Values);
static assert(isRandomAccessRange!Values);
static assert(hasSlicing!Values);
static assert(hasLength!Values);
assert(values.length == argCount);
assert(values[0 .. $].equal(values[0 .. values.length]));
assert(values.joiner(" ").equal(joinedRange.front));
joinedRange.popFront();
}}
assert(saved.retro.equal(only(3, 2, 1)));
assert(saved.length == 3);
assert(saved.back == 3);
saved.popBack();
assert(saved.length == 2);
assert(saved.back == 2);
assert(saved.front == 1);
saved.popFront();
assert(saved.length == 1);
assert(saved.front == 2);
saved.popBack();
assert(saved.empty);
auto imm = only!(immutable int, immutable int)(42, 24);
alias Imm = typeof(imm);
static assert(is(ElementType!Imm == immutable(int)));
assert(!imm.empty);
assert(imm.init.empty); // Issue 13441
assert(imm.front == 42);
imm.popFront();
assert(imm.front == 24);
imm.popFront();
assert(imm.empty);
static struct Test { int* a; }
immutable(Test) test;
cast(void) only(test, test); // Works with mutable indirection
}
/**
Iterate over `range` with an attached index variable.
Each element is a $(REF Tuple, std,typecons) containing the index
and the element, in that order, where the index member is named `index`
and the element member is named `value`.
The index starts at `start` and is incremented by one on every iteration.
Overflow:
If `range` has length, then it is an error to pass a value for `start`
so that `start + range.length` is bigger than `Enumerator.max`, thus
it is ensured that overflow cannot happen.
If `range` does not have length, and `popFront` is called when
`front.index == Enumerator.max`, the index will overflow and
continue from `Enumerator.min`.
Params:
range = the $(REF_ALTTEXT input range, isInputRange, std,range,primitives) to attach indexes to
start = the number to start the index counter from
Returns:
At minimum, an input range. All other range primitives are given in the
resulting range if `range` has them. The exceptions are the bidirectional
primitives, which are propagated only if `range` has length.
Example:
Useful for using `foreach` with an index loop variable:
----
import std.stdio : stdin, stdout;
import std.range : enumerate;
foreach (lineNum, line; stdin.byLine().enumerate(1))
stdout.writefln("line #%s: %s", lineNum, line);
----
*/
auto enumerate(Enumerator = size_t, Range)(Range range, Enumerator start = 0)
if (isIntegral!Enumerator && isInputRange!Range)
in
{
static if (hasLength!Range)
{
// TODO: core.checkedint supports mixed signedness yet?
import core.checkedint : adds, addu;
import std.conv : ConvException, to;
import std.traits : isSigned, Largest, Signed;
alias LengthType = typeof(range.length);
bool overflow;
static if (isSigned!Enumerator && isSigned!LengthType)
auto result = adds(start, range.length, overflow);
else static if (isSigned!Enumerator)
{
Largest!(Enumerator, Signed!LengthType) signedLength;
try signedLength = to!(typeof(signedLength))(range.length);
catch (ConvException)
overflow = true;
catch (Exception)
assert(false);
auto result = adds(start, signedLength, overflow);
}
else
{
static if (isSigned!LengthType)
assert(range.length >= 0);
auto result = addu(start, range.length, overflow);
}
assert(!overflow && result <= Enumerator.max);
}
}
do
{
// TODO: Relax isIntegral!Enumerator to allow user-defined integral types
static struct Result
{
import std.typecons : Tuple;
private:
alias ElemType = Tuple!(Enumerator, "index", ElementType!Range, "value");
Range range;
Unqual!Enumerator index;
public:
ElemType front() @property
{
assert(!range.empty, "Attempting to fetch the front of an empty enumerate");
return typeof(return)(index, range.front);
}
static if (isInfinite!Range)
enum bool empty = false;
else
{
bool empty() @property
{
return range.empty;
}
}
void popFront()
{
assert(!range.empty, "Attempting to popFront an empty enumerate");
range.popFront();
++index; // When !hasLength!Range, overflow is expected
}
static if (isForwardRange!Range)
{
Result save() @property
{
return typeof(return)(range.save, index);
}
}
static if (hasLength!Range)
{
size_t length() @property
{
return range.length;
}
alias opDollar = length;
static if (isBidirectionalRange!Range)
{
ElemType back() @property
{
assert(!range.empty, "Attempting to fetch the back of an empty enumerate");
return typeof(return)(cast(Enumerator)(index + range.length - 1), range.back);
}
void popBack()
{
assert(!range.empty, "Attempting to popBack an empty enumerate");
range.popBack();
}
}
}
static if (isRandomAccessRange!Range)
{
ElemType opIndex(size_t i)
{
return typeof(return)(cast(Enumerator)(index + i), range[i]);
}
}
static if (hasSlicing!Range)
{
static if (hasLength!Range)
{
Result opSlice(size_t i, size_t j)
{
return typeof(return)(range[i .. j], cast(Enumerator)(index + i));
}
}
else
{
static struct DollarToken {}
enum opDollar = DollarToken.init;
Result opSlice(size_t i, DollarToken)
{
return typeof(return)(range[i .. $], cast(Enumerator)(index + i));
}
auto opSlice(size_t i, size_t j)
{
return this[i .. $].takeExactly(j - 1);
}
}
}
}
return Result(range, start);
}
/// Can start enumeration from a negative position:
pure @safe nothrow unittest
{
import std.array : assocArray;
import std.range : enumerate;
bool[int] aa = true.repeat(3).enumerate(-1).assocArray();
assert(aa[-1]);
assert(aa[0]);
assert(aa[1]);
}
// Make sure passing qualified types works
pure @safe nothrow unittest
{
char[4] v;
immutable start = 2;
v[2 .. $].enumerate(start);
}
pure @safe nothrow unittest
{
import std.internal.test.dummyrange : AllDummyRanges;
import std.meta : AliasSeq;
import std.typecons : tuple;
static struct HasSlicing
{
typeof(this) front() @property { return typeof(this).init; }
bool empty() @property { return true; }
void popFront() {}
typeof(this) opSlice(size_t, size_t)
{
return typeof(this)();
}
}
static foreach (DummyType; AliasSeq!(AllDummyRanges, HasSlicing))
{{
alias R = typeof(enumerate(DummyType.init));
static assert(isInputRange!R);
static assert(isForwardRange!R == isForwardRange!DummyType);
static assert(isRandomAccessRange!R == isRandomAccessRange!DummyType);
static assert(!hasAssignableElements!R);
static if (hasLength!DummyType)
{
static assert(hasLength!R);
static assert(isBidirectionalRange!R ==
isBidirectionalRange!DummyType);
}
static assert(hasSlicing!R == hasSlicing!DummyType);
}}
static immutable values = ["zero", "one", "two", "three"];
auto enumerated = values[].enumerate();
assert(!enumerated.empty);
assert(enumerated.front == tuple(0, "zero"));
assert(enumerated.back == tuple(3, "three"));
typeof(enumerated) saved = enumerated.save;
saved.popFront();
assert(enumerated.front == tuple(0, "zero"));
assert(saved.front == tuple(1, "one"));
assert(saved.length == enumerated.length - 1);
saved.popBack();
assert(enumerated.back == tuple(3, "three"));
assert(saved.back == tuple(2, "two"));
saved.popFront();
assert(saved.front == tuple(2, "two"));
assert(saved.back == tuple(2, "two"));
saved.popFront();
assert(saved.empty);
size_t control = 0;
foreach (i, v; enumerated)
{
static assert(is(typeof(i) == size_t));
static assert(is(typeof(v) == typeof(values[0])));
assert(i == control);
assert(v == values[i]);
assert(tuple(i, v) == enumerated[i]);
++control;
}
assert(enumerated[0 .. $].front == tuple(0, "zero"));
assert(enumerated[$ - 1 .. $].front == tuple(3, "three"));
foreach (i; 0 .. 10)
{
auto shifted = values[0 .. 2].enumerate(i);
assert(shifted.front == tuple(i, "zero"));
assert(shifted[0] == shifted.front);
auto next = tuple(i + 1, "one");
assert(shifted[1] == next);
shifted.popFront();
assert(shifted.front == next);
shifted.popFront();
assert(shifted.empty);
}
static foreach (T; AliasSeq!(ubyte, byte, uint, int))
{{
auto inf = 42.repeat().enumerate(T.max);
alias Inf = typeof(inf);
static assert(isInfinite!Inf);
static assert(hasSlicing!Inf);
// test overflow
assert(inf.front == tuple(T.max, 42));
inf.popFront();
assert(inf.front == tuple(T.min, 42));
// test slicing
inf = inf[42 .. $];
assert(inf.front == tuple(T.min + 42, 42));
auto window = inf[0 .. 2];
assert(window.length == 1);
assert(window.front == inf.front);
window.popFront();
assert(window.empty);
}}
}
pure @safe unittest
{
import std.algorithm.comparison : equal;
import std.meta : AliasSeq;
static immutable int[] values = [0, 1, 2, 3, 4];
static foreach (T; AliasSeq!(ubyte, ushort, uint, ulong))
{{
auto enumerated = values.enumerate!T();
static assert(is(typeof(enumerated.front.index) == T));
assert(enumerated.equal(values[].zip(values)));
foreach (T i; 0 .. 5)
{
auto subset = values[cast(size_t) i .. $];
auto offsetEnumerated = subset.enumerate(i);
static assert(is(typeof(enumerated.front.index) == T));
assert(offsetEnumerated.equal(subset.zip(subset)));
}
}}
}
version (none) // @@@BUG@@@ 10939
{
// Re-enable (or remove) if 10939 is resolved.
/+pure+/ @safe unittest // Impure because of std.conv.to
{
import core.exception : RangeError;
import std.exception : assertNotThrown, assertThrown;
import std.meta : AliasSeq;
static immutable values = [42];
static struct SignedLengthRange
{
immutable(int)[] _values = values;
int front() @property { assert(false); }
bool empty() @property { assert(false); }
void popFront() { assert(false); }
int length() @property
{
return cast(int)_values.length;
}
}
SignedLengthRange svalues;
static foreach (Enumerator; AliasSeq!(ubyte, byte, ushort, short, uint, int, ulong, long))
{
assertThrown!RangeError(values[].enumerate!Enumerator(Enumerator.max));
assertNotThrown!RangeError(values[].enumerate!Enumerator(Enumerator.max - values.length));
assertThrown!RangeError(values[].enumerate!Enumerator(Enumerator.max - values.length + 1));
assertThrown!RangeError(svalues.enumerate!Enumerator(Enumerator.max));
assertNotThrown!RangeError(svalues.enumerate!Enumerator(Enumerator.max - values.length));
assertThrown!RangeError(svalues.enumerate!Enumerator(Enumerator.max - values.length + 1));
}
static foreach (Enumerator; AliasSeq!(byte, short, int))
{
assertThrown!RangeError(repeat(0, uint.max).enumerate!Enumerator());
}
assertNotThrown!RangeError(repeat(0, uint.max).enumerate!long());
}
}
/**
Returns true if `fn` accepts variables of type T1 and T2 in any order.
The following code should compile:
---
T1 foo();
T2 bar();
fn(foo(), bar());
fn(bar(), foo());
---
*/
template isTwoWayCompatible(alias fn, T1, T2)
{
enum isTwoWayCompatible = is(typeof( (){
T1 foo();
T2 bar();
cast(void) fn(foo(), bar());
cast(void) fn(bar(), foo());
}
));
}
///
@safe unittest
{
void func1(int a, int b);
void func2(int a, float b);
static assert(isTwoWayCompatible!(func1, int, int));
static assert(isTwoWayCompatible!(func1, short, int));
static assert(!isTwoWayCompatible!(func2, int, float));
}
/**
Policy used with the searching primitives `lowerBound`, $(D
upperBound), and `equalRange` of $(LREF SortedRange) below.
*/
enum SearchPolicy
{
/**
Searches in a linear fashion.
*/
linear,
/**
Searches with a step that is grows linearly (1, 2, 3,...)
leading to a quadratic search schedule (indexes tried are 0, 1,
3, 6, 10, 15, 21, 28,...) Once the search overshoots its target,
the remaining interval is searched using binary search. The
search is completed in $(BIGOH sqrt(n)) time. Use it when you
are reasonably confident that the value is around the beginning
of the range.
*/
trot,
/**
Performs a $(LINK2 https://en.wikipedia.org/wiki/Exponential_search,
galloping search algorithm), i.e. searches
with a step that doubles every time, (1, 2, 4, 8, ...) leading
to an exponential search schedule (indexes tried are 0, 1, 3,
7, 15, 31, 63,...) Once the search overshoots its target, the
remaining interval is searched using binary search. A value is
found in $(BIGOH log(n)) time.
*/
gallop,
/**
Searches using a classic interval halving policy. The search
starts in the middle of the range, and each search step cuts
the range in half. This policy finds a value in $(BIGOH log(n))
time but is less cache friendly than `gallop` for large
ranges. The `binarySearch` policy is used as the last step
of `trot`, `gallop`, `trotBackwards`, and $(D
gallopBackwards) strategies.
*/
binarySearch,
/**
Similar to `trot` but starts backwards. Use it when
confident that the value is around the end of the range.
*/
trotBackwards,
/**
Similar to `gallop` but starts backwards. Use it when
confident that the value is around the end of the range.
*/
gallopBackwards
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
auto a = assumeSorted([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
auto p1 = a.upperBound!(SearchPolicy.binarySearch)(3);
assert(p1.equal([4, 5, 6, 7, 8, 9]));
auto p2 = a.lowerBound!(SearchPolicy.gallop)(4);
assert(p2.equal([0, 1, 2, 3]));
}
/**
Options for $(LREF SortedRange) ranges (below).
*/
enum SortedRangeOptions
{
/**
Assume, that the range is sorted without checking.
*/
assumeSorted,
/**
All elements of the range are checked to be sorted.
The check is performed in O(n) time.
*/
checkStrictly,
/**
Some elements of the range are checked to be sorted.
For ranges with random order, this will almost surely
detect, that it is not sorted. For almost sorted ranges
it's more likely to fail. The checked elements are choosen
in a deterministic manner, which makes this check reproducable.
The check is performed in O(log(n)) time.
*/
checkRoughly,
}
///
@safe pure unittest
{
// create a SortedRange, that's checked strictly
SortedRange!(int[],"a < b", SortedRangeOptions.checkStrictly)([ 1, 3, 5, 7, 9 ]);
}
/**
Represents a sorted range. In addition to the regular range
primitives, supports additional operations that take advantage of the
ordering, such as merge and binary search. To obtain a $(D
SortedRange) from an unsorted range `r`, use
$(REF sort, std,algorithm,sorting) which sorts `r` in place and returns the
corresponding `SortedRange`. To construct a `SortedRange` from a range
`r` that is known to be already sorted, use $(LREF assumeSorted).
Params:
pred: The predicate used to define the sortedness
opt: Controls how strongly the range is checked for sortedness.
Will only be used for `RandomAccessRanges`.
Will not be used in CTFE.
*/
struct SortedRange(Range, alias pred = "a < b",
SortedRangeOptions opt = SortedRangeOptions.assumeSorted)
if (isInputRange!Range && !isInstanceOf!(SortedRange, Range))
{
import std.functional : binaryFun;
private alias predFun = binaryFun!pred;
private bool geq(L, R)(L lhs, R rhs)
{
return !predFun(lhs, rhs);
}
private bool gt(L, R)(L lhs, R rhs)
{
return predFun(rhs, lhs);
}
private Range _input;
// Undocummented because a clearer way to invoke is by calling
// assumeSorted.
this(Range input)
{
static if (opt == SortedRangeOptions.checkRoughly)
{
roughlyVerifySorted(input);
}
static if (opt == SortedRangeOptions.checkStrictly)
{
strictlyVerifySorted(input);
}
this._input = input;
}
// Assertion only.
static if (opt == SortedRangeOptions.checkRoughly)
private void roughlyVerifySorted(Range r)
{
if (!__ctfe)
{
static if (isRandomAccessRange!Range && hasLength!Range)
{
import core.bitop : bsr;
import std.algorithm.sorting : isSorted;
import std.exception : enforce;
// Check the sortedness of the input
if (r.length < 2) return;
immutable size_t msb = bsr(r.length) + 1;
assert(msb > 0 && msb <= r.length);
immutable step = r.length / msb;
auto st = stride(r, step);
enforce(isSorted!pred(st), "Range is not sorted");
}
}
}
// Assertion only.
static if (opt == SortedRangeOptions.checkStrictly)
private void strictlyVerifySorted(Range r)
{
if (!__ctfe)
{
static if (isRandomAccessRange!Range && hasLength!Range)
{
import std.algorithm.sorting : isSorted;
import std.exception : enforce;
enforce(isSorted!pred(r), "Range is not sorted");
}
}
}
/// Range primitives.
@property bool empty() //const
{
return this._input.empty;
}
/// Ditto
static if (isForwardRange!Range)
@property auto save()
{
// Avoid the constructor
typeof(this) result = this;
result._input = _input.save;
return result;
}
/// Ditto
@property auto ref front()
{
return _input.front;
}
/// Ditto
void popFront()
{
_input.popFront();
}
/// Ditto
static if (isBidirectionalRange!Range)
{
@property auto ref back()
{
return _input.back;
}
/// Ditto
void popBack()
{
_input.popBack();
}
}
/// Ditto
static if (isRandomAccessRange!Range)
auto ref opIndex(size_t i)
{
return _input[i];
}
/// Ditto
static if (hasSlicing!Range)
auto opSlice(size_t a, size_t b) return scope
{
assert(
a <= b,
"Attempting to slice a SortedRange with a larger first argument than the second."
);
typeof(this) result = this;
result._input = _input[a .. b];// skip checking
return result;
}
/// Ditto
static if (hasLength!Range)
{
@property size_t length() //const
{
return _input.length;
}
alias opDollar = length;
}
/**
Releases the controlled range and returns it.
*/
auto release()
{
import std.algorithm.mutation : move;
return move(_input);
}
// Assuming a predicate "test" that returns 0 for a left portion
// of the range and then 1 for the rest, returns the index at
// which the first 1 appears. Used internally by the search routines.
private size_t getTransitionIndex(SearchPolicy sp, alias test, V)(V v)
if (sp == SearchPolicy.binarySearch && isRandomAccessRange!Range && hasLength!Range)
{
size_t first = 0, count = _input.length;
while (count > 0)
{
immutable step = count / 2, it = first + step;
if (!test(_input[it], v))
{
first = it + 1;
count -= step + 1;
}
else
{
count = step;
}
}
return first;
}
// Specialization for trot and gallop
private size_t getTransitionIndex(SearchPolicy sp, alias test, V)(V v)
if ((sp == SearchPolicy.trot || sp == SearchPolicy.gallop)
&& isRandomAccessRange!Range)
{
if (empty || test(front, v)) return 0;
immutable count = length;
if (count == 1) return 1;
size_t below = 0, above = 1, step = 2;
while (!test(_input[above], v))
{
// Still too small, update below and increase gait
below = above;
immutable next = above + step;
if (next >= count)
{
// Overshot - the next step took us beyond the end. So
// now adjust next and simply exit the loop to do the
// binary search thingie.
above = count;
break;
}
// Still in business, increase step and continue
above = next;
static if (sp == SearchPolicy.trot)
++step;
else
step <<= 1;
}
return below + this[below .. above].getTransitionIndex!(
SearchPolicy.binarySearch, test, V)(v);
}
// Specialization for trotBackwards and gallopBackwards
private size_t getTransitionIndex(SearchPolicy sp, alias test, V)(V v)
if ((sp == SearchPolicy.trotBackwards || sp == SearchPolicy.gallopBackwards)
&& isRandomAccessRange!Range)
{
immutable count = length;
if (empty || !test(back, v)) return count;
if (count == 1) return 0;
size_t below = count - 2, above = count - 1, step = 2;
while (test(_input[below], v))
{
// Still too large, update above and increase gait
above = below;
if (below < step)
{
// Overshot - the next step took us beyond the end. So
// now adjust next and simply fall through to do the
// binary search thingie.
below = 0;
break;
}
// Still in business, increase step and continue
below -= step;
static if (sp == SearchPolicy.trot)
++step;
else
step <<= 1;
}
return below + this[below .. above].getTransitionIndex!(
SearchPolicy.binarySearch, test, V)(v);
}
// lowerBound
/**
This function uses a search with policy `sp` to find the
largest left subrange on which $(D pred(x, value)) is `true` for
all `x` (e.g., if `pred` is "less than", returns the portion of
the range with elements strictly smaller than `value`). The search
schedule and its complexity are documented in
$(LREF SearchPolicy).
*/
auto lowerBound(SearchPolicy sp = SearchPolicy.binarySearch, V)(V value)
if (isTwoWayCompatible!(predFun, ElementType!Range, V)
&& hasSlicing!Range)
{
return this[0 .. getTransitionIndex!(sp, geq)(value)];
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
auto a = assumeSorted([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]);
auto p = a.lowerBound(4);
assert(equal(p, [ 0, 1, 2, 3 ]));
}
// upperBound
/**
This function searches with policy `sp` to find the largest right
subrange on which $(D pred(value, x)) is `true` for all `x`
(e.g., if `pred` is "less than", returns the portion of the range
with elements strictly greater than `value`). The search schedule
and its complexity are documented in $(LREF SearchPolicy).
For ranges that do not offer random access, `SearchPolicy.linear`
is the only policy allowed (and it must be specified explicitly lest it exposes
user code to unexpected inefficiencies). For random-access searches, all
policies are allowed, and `SearchPolicy.binarySearch` is the default.
*/
auto upperBound(SearchPolicy sp = SearchPolicy.binarySearch, V)(V value)
if (isTwoWayCompatible!(predFun, ElementType!Range, V))
{
static assert(hasSlicing!Range || sp == SearchPolicy.linear,
"Specify SearchPolicy.linear explicitly for "
~ typeof(this).stringof);
static if (sp == SearchPolicy.linear)
{
for (; !_input.empty && !predFun(value, _input.front);
_input.popFront())
{
}
return this;
}
else
{
return this[getTransitionIndex!(sp, gt)(value) .. length];
}
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
auto a = assumeSorted([ 1, 2, 3, 3, 3, 4, 4, 5, 6 ]);
auto p = a.upperBound(3);
assert(equal(p, [4, 4, 5, 6]));
}
// equalRange
/**
Returns the subrange containing all elements `e` for which both $(D
pred(e, value)) and $(D pred(value, e)) evaluate to `false` (e.g.,
if `pred` is "less than", returns the portion of the range with
elements equal to `value`). Uses a classic binary search with
interval halving until it finds a value that satisfies the condition,
then uses `SearchPolicy.gallopBackwards` to find the left boundary
and `SearchPolicy.gallop` to find the right boundary. These
policies are justified by the fact that the two boundaries are likely
to be near the first found value (i.e., equal ranges are relatively
small). Completes the entire search in $(BIGOH log(n)) time.
*/
auto equalRange(V)(V value)
if (isTwoWayCompatible!(predFun, ElementType!Range, V)
&& isRandomAccessRange!Range)
{
size_t first = 0, count = _input.length;
while (count > 0)
{
immutable step = count / 2;
auto it = first + step;
if (predFun(_input[it], value))
{
// Less than value, bump left bound up
first = it + 1;
count -= step + 1;
}
else if (predFun(value, _input[it]))
{
// Greater than value, chop count
count = step;
}
else
{
// Equal to value, do binary searches in the
// leftover portions
// Gallop towards the left end as it's likely nearby
immutable left = first
+ this[first .. it]
.lowerBound!(SearchPolicy.gallopBackwards)(value).length;
first += count;
// Gallop towards the right end as it's likely nearby
immutable right = first
- this[it + 1 .. first]
.upperBound!(SearchPolicy.gallop)(value).length;
return this[left .. right];
}
}
return this.init;
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
auto a = [ 1, 2, 3, 3, 3, 4, 4, 5, 6 ];
auto r = a.assumeSorted.equalRange(3);
assert(equal(r, [ 3, 3, 3 ]));
}
// trisect
/**
Returns a tuple `r` such that `r[0]` is the same as the result
of `lowerBound(value)`, `r[1]` is the same as the result of $(D
equalRange(value)), and `r[2]` is the same as the result of $(D
upperBound(value)). The call is faster than computing all three
separately. Uses a search schedule similar to $(D
equalRange). Completes the entire search in $(BIGOH log(n)) time.
*/
auto trisect(V)(V value)
if (isTwoWayCompatible!(predFun, ElementType!Range, V)
&& isRandomAccessRange!Range && hasLength!Range)
{
import std.typecons : tuple;
size_t first = 0, count = _input.length;
while (count > 0)
{
immutable step = count / 2;
auto it = first + step;
if (predFun(_input[it], value))
{
// Less than value, bump left bound up
first = it + 1;
count -= step + 1;
}
else if (predFun(value, _input[it]))
{
// Greater than value, chop count
count = step;
}
else
{
// Equal to value, do binary searches in the
// leftover portions
// Gallop towards the left end as it's likely nearby
immutable left = first
+ this[first .. it]
.lowerBound!(SearchPolicy.gallopBackwards)(value).length;
first += count;
// Gallop towards the right end as it's likely nearby
immutable right = first
- this[it + 1 .. first]
.upperBound!(SearchPolicy.gallop)(value).length;
return tuple(this[0 .. left], this[left .. right],
this[right .. length]);
}
}
// No equal element was found
return tuple(this[0 .. first], this.init, this[first .. length]);
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
auto a = [ 1, 2, 3, 3, 3, 4, 4, 5, 6 ];
auto r = assumeSorted(a).trisect(3);
assert(equal(r[0], [ 1, 2 ]));
assert(equal(r[1], [ 3, 3, 3 ]));
assert(equal(r[2], [ 4, 4, 5, 6 ]));
}
// contains
/**
Returns `true` if and only if `value` can be found in $(D
range), which is assumed to be sorted. Performs $(BIGOH log(r.length))
evaluations of `pred`.
*/
bool contains(V)(V value)
if (isRandomAccessRange!Range)
{
if (empty) return false;
immutable i = getTransitionIndex!(SearchPolicy.binarySearch, geq)(value);
if (i >= length) return false;
return !predFun(value, _input[i]);
}
/**
Like `contains`, but the value is specified before the range.
*/
auto opBinaryRight(string op, V)(V value)
if (op == "in" && isRandomAccessRange!Range)
{
return contains(value);
}
// groupBy
/**
Returns a range of subranges of elements that are equivalent according to the
sorting relation.
*/
auto groupBy()()
{
import std.algorithm.iteration : chunkBy;
return _input.chunkBy!((a, b) => !predFun(a, b) && !predFun(b, a));
}
}
/// ditto
template SortedRange(Range, alias pred = "a < b",
SortedRangeOptions opt = SortedRangeOptions.assumeSorted)
if (isInstanceOf!(SortedRange, Range))
{
// Avoid nesting SortedRange types (see Issue 18933);
alias SortedRange = SortedRange!(Unqual!(typeof(Range._input)), pred, opt);
}
///
@safe unittest
{
import std.algorithm.sorting : sort;
auto a = [ 1, 2, 3, 42, 52, 64 ];
auto r = assumeSorted(a);
assert(r.contains(3));
assert(!(32 in r));
auto r1 = sort!"a > b"(a);
assert(3 in r1);
assert(!r1.contains(32));
assert(r1.release() == [ 64, 52, 42, 3, 2, 1 ]);
}
/**
`SortedRange` could accept ranges weaker than random-access, but it
is unable to provide interesting functionality for them. Therefore,
`SortedRange` is currently restricted to random-access ranges.
No copy of the original range is ever made. If the underlying range is
changed concurrently with its corresponding `SortedRange` in ways
that break its sorted-ness, `SortedRange` will work erratically.
*/
@safe unittest
{
import std.algorithm.mutation : swap;
auto a = [ 1, 2, 3, 42, 52, 64 ];
auto r = assumeSorted(a);
assert(r.contains(42));
swap(a[3], a[5]); // illegal to break sortedness of original range
assert(!r.contains(42)); // passes although it shouldn't
}
@safe unittest
{
import std.exception : assertThrown, assertNotThrown;
assertNotThrown(SortedRange!(int[])([ 1, 3, 10, 5, 7 ]));
assertThrown(SortedRange!(int[],"a < b", SortedRangeOptions.checkStrictly)([ 1, 3, 10, 5, 7 ]));
// these two checks are implementation depended
assertNotThrown(SortedRange!(int[],"a < b", SortedRangeOptions.checkRoughly)([ 1, 3, 10, 5, 12, 2 ]));
assertThrown(SortedRange!(int[],"a < b", SortedRangeOptions.checkRoughly)([ 1, 3, 10, 5, 2, 12 ]));
}
@safe unittest
{
import std.algorithm.comparison : equal;
auto a = [ 10, 20, 30, 30, 30, 40, 40, 50, 60 ];
auto r = assumeSorted(a).trisect(30);
assert(equal(r[0], [ 10, 20 ]));
assert(equal(r[1], [ 30, 30, 30 ]));
assert(equal(r[2], [ 40, 40, 50, 60 ]));
r = assumeSorted(a).trisect(35);
assert(equal(r[0], [ 10, 20, 30, 30, 30 ]));
assert(r[1].empty);
assert(equal(r[2], [ 40, 40, 50, 60 ]));
}
@safe unittest
{
import std.algorithm.comparison : equal;
auto a = [ "A", "AG", "B", "E", "F" ];
auto r = assumeSorted!"cmp(a,b) < 0"(a).trisect("B"w);
assert(equal(r[0], [ "A", "AG" ]));
assert(equal(r[1], [ "B" ]));
assert(equal(r[2], [ "E", "F" ]));
r = assumeSorted!"cmp(a,b) < 0"(a).trisect("A"d);
assert(r[0].empty);
assert(equal(r[1], [ "A" ]));
assert(equal(r[2], [ "AG", "B", "E", "F" ]));
}
@safe unittest
{
import std.algorithm.comparison : equal;
static void test(SearchPolicy pol)()
{
auto a = [ 1, 2, 3, 42, 52, 64 ];
auto r = assumeSorted(a);
assert(equal(r.lowerBound(42), [1, 2, 3]));
assert(equal(r.lowerBound!(pol)(42), [1, 2, 3]));
assert(equal(r.lowerBound!(pol)(41), [1, 2, 3]));
assert(equal(r.lowerBound!(pol)(43), [1, 2, 3, 42]));
assert(equal(r.lowerBound!(pol)(51), [1, 2, 3, 42]));
assert(equal(r.lowerBound!(pol)(3), [1, 2]));
assert(equal(r.lowerBound!(pol)(55), [1, 2, 3, 42, 52]));
assert(equal(r.lowerBound!(pol)(420), a));
assert(equal(r.lowerBound!(pol)(0), a[0 .. 0]));
assert(equal(r.upperBound!(pol)(42), [52, 64]));
assert(equal(r.upperBound!(pol)(41), [42, 52, 64]));
assert(equal(r.upperBound!(pol)(43), [52, 64]));
assert(equal(r.upperBound!(pol)(51), [52, 64]));
assert(equal(r.upperBound!(pol)(53), [64]));
assert(equal(r.upperBound!(pol)(55), [64]));
assert(equal(r.upperBound!(pol)(420), a[0 .. 0]));
assert(equal(r.upperBound!(pol)(0), a));
}
test!(SearchPolicy.trot)();
test!(SearchPolicy.gallop)();
test!(SearchPolicy.trotBackwards)();
test!(SearchPolicy.gallopBackwards)();
test!(SearchPolicy.binarySearch)();
}
@safe unittest
{
// Check for small arrays
int[] a;
auto r = assumeSorted(a);
a = [ 1 ];
r = assumeSorted(a);
a = [ 1, 2 ];
r = assumeSorted(a);
a = [ 1, 2, 3 ];
r = assumeSorted(a);
}
@safe unittest
{
import std.algorithm.mutation : swap;
auto a = [ 1, 2, 3, 42, 52, 64 ];
auto r = assumeSorted(a);
assert(r.contains(42));
swap(a[3], a[5]); // illegal to break sortedness of original range
assert(!r.contains(42)); // passes although it shouldn't
}
@betterC @nogc nothrow @safe unittest
{
static immutable(int)[] arr = [ 1, 2, 3 ];
auto s = assumeSorted(arr);
}
@system unittest
{
import std.algorithm.comparison : equal;
int[] arr = [100, 101, 102, 200, 201, 300];
auto s = assumeSorted!((a, b) => a / 100 < b / 100)(arr);
assert(s.groupBy.equal!equal([[100, 101, 102], [200, 201], [300]]));
}
// Test on an input range
@system unittest
{
import std.conv : text;
import std.file : exists, remove, tempDir;
import std.path : buildPath;
import std.stdio : File;
import std.uuid : randomUUID;
auto name = buildPath(tempDir(), "test.std.range.line-" ~ text(__LINE__) ~
"." ~ randomUUID().toString());
auto f = File(name, "w");
scope(exit) if (exists(name)) remove(name);
// write a sorted range of lines to the file
f.write("abc\ndef\nghi\njkl");
f.close();
f.open(name, "r");
auto r = assumeSorted(f.byLine());
auto r1 = r.upperBound!(SearchPolicy.linear)("def");
assert(r1.front == "ghi", r1.front);
f.close();
}
// https://issues.dlang.org/show_bug.cgi?id=19337
@safe unittest
{
import std.algorithm.sorting : sort;
auto a = [ 1, 2, 3, 42, 52, 64 ];
a.sort.sort!"a > b";
}
/**
Assumes `r` is sorted by predicate `pred` and returns the
corresponding $(D SortedRange!(pred, R)) having `r` as support.
To check for sorted-ness at
cost $(BIGOH n), use $(REF isSorted, std,algorithm,sorting).
*/
auto assumeSorted(alias pred = "a < b", R)(R r)
if (isInputRange!(Unqual!R))
{
// Avoid senseless `SortedRange!(SortedRange!(...), pred)` nesting.
static if (is(R == SortedRange!(RRange, RPred), RRange, alias RPred))
{
static if (isInputRange!R && __traits(isSame, pred, RPred))
// If the predicate is the same and we don't need to cast away
// constness for the result to be an input range.
return r;
else
return SortedRange!(Unqual!(typeof(r._input)), pred)(r._input);
}
else
{
return SortedRange!(Unqual!R, pred)(r);
}
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
int[] a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
auto p = assumeSorted(a);
assert(equal(p.lowerBound(4), [0, 1, 2, 3]));
assert(equal(p.lowerBound(5), [0, 1, 2, 3, 4]));
assert(equal(p.lowerBound(6), [0, 1, 2, 3, 4, 5]));
assert(equal(p.lowerBound(6.9), [0, 1, 2, 3, 4, 5, 6]));
}
@safe unittest
{
import std.algorithm.comparison : equal;
static assert(isRandomAccessRange!(SortedRange!(int[])));
int[] a = [ 1, 2, 3, 3, 3, 4, 4, 5, 6 ];
auto p = assumeSorted(a).upperBound(3);
assert(equal(p, [4, 4, 5, 6 ]));
p = assumeSorted(a).upperBound(4.2);
assert(equal(p, [ 5, 6 ]));
// Issue 18933 - don't create senselessly nested SortedRange types.
assert(is(typeof(assumeSorted(a)) == typeof(assumeSorted(assumeSorted(a)))));
assert(is(typeof(assumeSorted(a)) == typeof(assumeSorted(assumeSorted!"a > b"(a)))));
}
@safe unittest
{
import std.algorithm.comparison : equal;
import std.conv : text;
int[] a = [ 1, 2, 3, 3, 3, 4, 4, 5, 6 ];
auto p = assumeSorted(a).equalRange(3);
assert(equal(p, [ 3, 3, 3 ]), text(p));
p = assumeSorted(a).equalRange(4);
assert(equal(p, [ 4, 4 ]), text(p));
p = assumeSorted(a).equalRange(2);
assert(equal(p, [ 2 ]));
p = assumeSorted(a).equalRange(0);
assert(p.empty);
p = assumeSorted(a).equalRange(7);
assert(p.empty);
p = assumeSorted(a).equalRange(3.0);
assert(equal(p, [ 3, 3, 3]));
}
@safe unittest
{
int[] a = [ 1, 2, 3, 3, 3, 4, 4, 5, 6 ];
if (a.length)
{
auto b = a[a.length / 2];
//auto r = sort(a);
//assert(r.contains(b));
}
}
@safe unittest
{
auto a = [ 5, 7, 34, 345, 677 ];
auto r = assumeSorted(a);
a = null;
r = assumeSorted(a);
a = [ 1 ];
r = assumeSorted(a);
}
// issue 15003
@nogc @safe unittest
{
static immutable a = [1, 2, 3, 4];
auto r = a.assumeSorted;
}
/++
Wrapper which effectively makes it possible to pass a range by reference.
Both the original range and the RefRange will always have the exact same
elements. Any operation done on one will affect the other. So, for instance,
if it's passed to a function which would implicitly copy the original range
if it were passed to it, the original range is $(I not) copied but is
consumed as if it were a reference type.
Note:
`save` works as normal and operates on a new range, so if
`save` is ever called on the `RefRange`, then no operations on the
saved range will affect the original.
Params:
range = the range to construct the `RefRange` from
Returns:
A `RefRange`. If the given range is a class type
(and thus is already a reference type), then the original
range is returned rather than a `RefRange`.
+/
struct RefRange(R)
if (isInputRange!R)
{
public:
/++ +/
this(R* range) @safe pure nothrow
{
_range = range;
}
/++
This does not assign the pointer of `rhs` to this `RefRange`.
Rather it assigns the range pointed to by `rhs` to the range pointed
to by this `RefRange`. This is because $(I any) operation on a
`RefRange` is the same is if it occurred to the original range. The
one exception is when a `RefRange` is assigned `null` either
directly or because `rhs` is `null`. In that case, `RefRange`
no longer refers to the original range but is `null`.
+/
auto opAssign(RefRange rhs)
{
if (_range && rhs._range)
*_range = *rhs._range;
else
_range = rhs._range;
return this;
}
/++ +/
void opAssign(typeof(null) rhs)
{
_range = null;
}
/++
A pointer to the wrapped range.
+/
@property inout(R*) ptr() @safe inout pure nothrow
{
return _range;
}
version (StdDdoc)
{
/++ +/
@property auto front() {assert(0);}
/++ Ditto +/
@property auto front() const {assert(0);}
/++ Ditto +/
@property auto front(ElementType!R value) {assert(0);}
}
else
{
@property auto front()
{
return (*_range).front;
}
static if (is(typeof((*(cast(const R*)_range)).front))) @property auto front() const
{
return (*_range).front;
}
static if (is(typeof((*_range).front = (*_range).front))) @property auto front(ElementType!R value)
{
return (*_range).front = value;
}
}
version (StdDdoc)
{
@property bool empty(); ///
@property bool empty() const; ///Ditto
}
else static if (isInfinite!R)
enum empty = false;
else
{
@property bool empty()
{
return (*_range).empty;
}
static if (is(typeof((*cast(const R*)_range).empty))) @property bool empty() const
{
return (*_range).empty;
}
}
/++ +/
void popFront()
{
return (*_range).popFront();
}
version (StdDdoc)
{
/++
Only defined if `isForwardRange!R` is `true`.
+/
@property auto save() {assert(0);}
/++ Ditto +/
@property auto save() const {assert(0);}
/++ Ditto +/
auto opSlice() {assert(0);}
/++ Ditto +/
auto opSlice() const {assert(0);}
}
else static if (isForwardRange!R)
{
import std.traits : isSafe;
private alias S = typeof((*_range).save);
static if (is(typeof((*cast(const R*)_range).save)))
private alias CS = typeof((*cast(const R*)_range).save);
static if (isSafe!((R* r) => (*r).save))
{
@property RefRange!S save() @trusted
{
mixin(_genSave());
}
static if (is(typeof((*cast(const R*)_range).save))) @property RefRange!CS save() @trusted const
{
mixin(_genSave());
}
}
else
{
@property RefRange!S save()
{
mixin(_genSave());
}
static if (is(typeof((*cast(const R*)_range).save))) @property RefRange!CS save() const
{
mixin(_genSave());
}
}
auto opSlice()()
{
return save;
}
auto opSlice()() const
{
return save;
}
private static string _genSave() @safe pure nothrow
{
return `import std.conv : emplace;` ~
`alias S = typeof((*_range).save);` ~
`static assert(isForwardRange!S, S.stringof ~ " is not a forward range.");` ~
`auto mem = new void[S.sizeof];` ~
`emplace!S(mem, cast(S)(*_range).save);` ~
`return RefRange!S(cast(S*) mem.ptr);`;
}
static assert(isForwardRange!RefRange);
}
version (StdDdoc)
{
/++
Only defined if `isBidirectionalRange!R` is `true`.
+/
@property auto back() {assert(0);}
/++ Ditto +/
@property auto back() const {assert(0);}
/++ Ditto +/
@property auto back(ElementType!R value) {assert(0);}
}
else static if (isBidirectionalRange!R)
{
@property auto back()
{
return (*_range).back;
}
static if (is(typeof((*(cast(const R*)_range)).back))) @property auto back() const
{
return (*_range).back;
}
static if (is(typeof((*_range).back = (*_range).back))) @property auto back(ElementType!R value)
{
return (*_range).back = value;
}
}
/++ Ditto +/
static if (isBidirectionalRange!R) void popBack()
{
return (*_range).popBack();
}
version (StdDdoc)
{
/++
Only defined if `isRandomAccesRange!R` is `true`.
+/
auto ref opIndex(IndexType)(IndexType index) {assert(0);}
/++ Ditto +/
auto ref opIndex(IndexType)(IndexType index) const {assert(0);}
}
else static if (isRandomAccessRange!R)
{
auto ref opIndex(IndexType)(IndexType index)
if (is(typeof((*_range)[index])))
{
return (*_range)[index];
}
auto ref opIndex(IndexType)(IndexType index) const
if (is(typeof((*cast(const R*)_range)[index])))
{
return (*_range)[index];
}
}
/++
Only defined if `hasMobileElements!R` and `isForwardRange!R` are
`true`.
+/
static if (hasMobileElements!R && isForwardRange!R) auto moveFront()
{
return (*_range).moveFront();
}
/++
Only defined if `hasMobileElements!R` and `isBidirectionalRange!R`
are `true`.
+/
static if (hasMobileElements!R && isBidirectionalRange!R) auto moveBack()
{
return (*_range).moveBack();
}
/++
Only defined if `hasMobileElements!R` and `isRandomAccessRange!R`
are `true`.
+/
static if (hasMobileElements!R && isRandomAccessRange!R) auto moveAt(size_t index)
{
return (*_range).moveAt(index);
}
version (StdDdoc)
{
/++
Only defined if `hasLength!R` is `true`.
+/
@property auto length() {assert(0);}
/++ Ditto +/
@property auto length() const {assert(0);}
/++ Ditto +/
alias opDollar = length;
}
else static if (hasLength!R)
{
@property auto length()
{
return (*_range).length;
}
static if (is(typeof((*cast(const R*)_range).length))) @property auto length() const
{
return (*_range).length;
}
alias opDollar = length;
}
version (StdDdoc)
{
/++
Only defined if `hasSlicing!R` is `true`.
+/
auto opSlice(IndexType1, IndexType2)
(IndexType1 begin, IndexType2 end) {assert(0);}
/++ Ditto +/
auto opSlice(IndexType1, IndexType2)
(IndexType1 begin, IndexType2 end) const {assert(0);}
}
else static if (hasSlicing!R)
{
private alias T = typeof((*_range)[1 .. 2]);
static if (is(typeof((*cast(const R*)_range)[1 .. 2])))
{
private alias CT = typeof((*cast(const R*)_range)[1 .. 2]);
}
RefRange!T opSlice(IndexType1, IndexType2)
(IndexType1 begin, IndexType2 end)
if (is(typeof((*_range)[begin .. end])))
{
mixin(_genOpSlice());
}
RefRange!CT opSlice(IndexType1, IndexType2)
(IndexType1 begin, IndexType2 end) const
if (is(typeof((*cast(const R*)_range)[begin .. end])))
{
mixin(_genOpSlice());
}
private static string _genOpSlice() @safe pure nothrow
{
return `import std.conv : emplace;` ~
`alias S = typeof((*_range)[begin .. end]);` ~
`static assert(hasSlicing!S, S.stringof ~ " is not sliceable.");` ~
`auto mem = new void[S.sizeof];` ~
`emplace!S(mem, cast(S)(*_range)[begin .. end]);` ~
`return RefRange!S(cast(S*) mem.ptr);`;
}
}
private:
R* _range;
}
/// Basic Example
@system unittest
{
import std.algorithm.searching : find;
ubyte[] buffer = [1, 9, 45, 12, 22];
auto found1 = find(buffer, 45);
assert(found1 == [45, 12, 22]);
assert(buffer == [1, 9, 45, 12, 22]);
auto wrapped1 = refRange(&buffer);
auto found2 = find(wrapped1, 45);
assert(*found2.ptr == [45, 12, 22]);
assert(buffer == [45, 12, 22]);
auto found3 = find(wrapped1.save, 22);
assert(*found3.ptr == [22]);
assert(buffer == [45, 12, 22]);
string str = "hello world";
auto wrappedStr = refRange(&str);
assert(str.front == 'h');
str.popFrontN(5);
assert(str == " world");
assert(wrappedStr.front == ' ');
assert(*wrappedStr.ptr == " world");
}
/// opAssign Example.
@system unittest
{
ubyte[] buffer1 = [1, 2, 3, 4, 5];
ubyte[] buffer2 = [6, 7, 8, 9, 10];
auto wrapped1 = refRange(&buffer1);
auto wrapped2 = refRange(&buffer2);
assert(wrapped1.ptr is &buffer1);
assert(wrapped2.ptr is &buffer2);
assert(wrapped1.ptr !is wrapped2.ptr);
assert(buffer1 != buffer2);
wrapped1 = wrapped2;
//Everything points to the same stuff as before.
assert(wrapped1.ptr is &buffer1);
assert(wrapped2.ptr is &buffer2);
assert(wrapped1.ptr !is wrapped2.ptr);
//But buffer1 has changed due to the assignment.
assert(buffer1 == [6, 7, 8, 9, 10]);
assert(buffer2 == [6, 7, 8, 9, 10]);
buffer2 = [11, 12, 13, 14, 15];
//Everything points to the same stuff as before.
assert(wrapped1.ptr is &buffer1);
assert(wrapped2.ptr is &buffer2);
assert(wrapped1.ptr !is wrapped2.ptr);
//But buffer2 has changed due to the assignment.
assert(buffer1 == [6, 7, 8, 9, 10]);
assert(buffer2 == [11, 12, 13, 14, 15]);
wrapped2 = null;
//The pointer changed for wrapped2 but not wrapped1.
assert(wrapped1.ptr is &buffer1);
assert(wrapped2.ptr is null);
assert(wrapped1.ptr !is wrapped2.ptr);
//buffer2 is not affected by the assignment.
assert(buffer1 == [6, 7, 8, 9, 10]);
assert(buffer2 == [11, 12, 13, 14, 15]);
}
@system unittest
{
import std.algorithm.iteration : filter;
{
ubyte[] buffer = [1, 2, 3, 4, 5];
auto wrapper = refRange(&buffer);
auto p = wrapper.ptr;
auto f = wrapper.front;
wrapper.front = f;
auto e = wrapper.empty;
wrapper.popFront();
auto s = wrapper.save;
auto b = wrapper.back;
wrapper.back = b;
wrapper.popBack();
auto i = wrapper[0];
wrapper.moveFront();
wrapper.moveBack();
wrapper.moveAt(0);
auto l = wrapper.length;
auto sl = wrapper[0 .. 1];
assert(wrapper[0 .. $].length == buffer[0 .. $].length);
}
{
ubyte[] buffer = [1, 2, 3, 4, 5];
const wrapper = refRange(&buffer);
const p = wrapper.ptr;
const f = wrapper.front;
const e = wrapper.empty;
const s = wrapper.save;
const b = wrapper.back;
const i = wrapper[0];
const l = wrapper.length;
const sl = wrapper[0 .. 1];
}
{
ubyte[] buffer = [1, 2, 3, 4, 5];
auto filtered = filter!"true"(buffer);
auto wrapper = refRange(&filtered);
auto p = wrapper.ptr;
auto f = wrapper.front;
wrapper.front = f;
auto e = wrapper.empty;
wrapper.popFront();
auto s = wrapper.save;
wrapper.moveFront();
}
{
ubyte[] buffer = [1, 2, 3, 4, 5];
auto filtered = filter!"true"(buffer);
const wrapper = refRange(&filtered);
const p = wrapper.ptr;
//Cannot currently be const. filter needs to be updated to handle const.
/+
const f = wrapper.front;
const e = wrapper.empty;
const s = wrapper.save;
+/
}
{
string str = "hello world";
auto wrapper = refRange(&str);
auto p = wrapper.ptr;
auto f = wrapper.front;
auto e = wrapper.empty;
wrapper.popFront();
auto s = wrapper.save;
auto b = wrapper.back;
wrapper.popBack();
}
{
// Issue 16534 - opDollar should be defined if the
// wrapped range defines length.
auto range = 10.iota.takeExactly(5);
auto wrapper = refRange(&range);
assert(wrapper.length == 5);
assert(wrapper[0 .. $ - 1].length == 4);
}
}
//Test assignment.
@system unittest
{
ubyte[] buffer1 = [1, 2, 3, 4, 5];
ubyte[] buffer2 = [6, 7, 8, 9, 10];
RefRange!(ubyte[]) wrapper1;
RefRange!(ubyte[]) wrapper2 = refRange(&buffer2);
assert(wrapper1.ptr is null);
assert(wrapper2.ptr is &buffer2);
wrapper1 = refRange(&buffer1);
assert(wrapper1.ptr is &buffer1);
wrapper1 = wrapper2;
assert(wrapper1.ptr is &buffer1);
assert(buffer1 == buffer2);
wrapper1 = RefRange!(ubyte[]).init;
assert(wrapper1.ptr is null);
assert(wrapper2.ptr is &buffer2);
assert(buffer1 == buffer2);
assert(buffer1 == [6, 7, 8, 9, 10]);
wrapper2 = null;
assert(wrapper2.ptr is null);
assert(buffer2 == [6, 7, 8, 9, 10]);
}
@system unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.mutation : bringToFront;
import std.algorithm.searching : commonPrefix, find, until;
import std.algorithm.sorting : sort;
//Test that ranges are properly consumed.
{
int[] arr = [1, 42, 2, 41, 3, 40, 4, 42, 9];
auto wrapper = refRange(&arr);
assert(*find(wrapper, 41).ptr == [41, 3, 40, 4, 42, 9]);
assert(arr == [41, 3, 40, 4, 42, 9]);
assert(*drop(wrapper, 2).ptr == [40, 4, 42, 9]);
assert(arr == [40, 4, 42, 9]);
assert(equal(until(wrapper, 42), [40, 4]));
assert(arr == [42, 9]);
assert(find(wrapper, 12).empty);
assert(arr.empty);
}
{
string str = "Hello, world-like object.";
auto wrapper = refRange(&str);
assert(*find(wrapper, "l").ptr == "llo, world-like object.");
assert(str == "llo, world-like object.");
assert(equal(take(wrapper, 5), "llo, "));
assert(str == "world-like object.");
}
//Test that operating on saved ranges does not consume the original.
{
int[] arr = [1, 42, 2, 41, 3, 40, 4, 42, 9];
auto wrapper = refRange(&arr);
auto saved = wrapper.save;
saved.popFrontN(3);
assert(*saved.ptr == [41, 3, 40, 4, 42, 9]);
assert(arr == [1, 42, 2, 41, 3, 40, 4, 42, 9]);
}
{
string str = "Hello, world-like object.";
auto wrapper = refRange(&str);
auto saved = wrapper.save;
saved.popFrontN(13);
assert(*saved.ptr == "like object.");
assert(str == "Hello, world-like object.");
}
//Test that functions which use save work properly.
{
int[] arr = [1, 42];
auto wrapper = refRange(&arr);
assert(equal(commonPrefix(wrapper, [1, 27]), [1]));
}
{
int[] arr = [4, 5, 6, 7, 1, 2, 3];
auto wrapper = refRange(&arr);
assert(bringToFront(wrapper[0 .. 4], wrapper[4 .. arr.length]) == 3);
assert(arr == [1, 2, 3, 4, 5, 6, 7]);
}
//Test bidirectional functions.
{
int[] arr = [1, 42, 2, 41, 3, 40, 4, 42, 9];
auto wrapper = refRange(&arr);
assert(wrapper.back == 9);
assert(arr == [1, 42, 2, 41, 3, 40, 4, 42, 9]);
wrapper.popBack();
assert(arr == [1, 42, 2, 41, 3, 40, 4, 42]);
}
{
string str = "Hello, world-like object.";
auto wrapper = refRange(&str);
assert(wrapper.back == '.');
assert(str == "Hello, world-like object.");
wrapper.popBack();
assert(str == "Hello, world-like object");
}
//Test random access functions.
{
int[] arr = [1, 42, 2, 41, 3, 40, 4, 42, 9];
auto wrapper = refRange(&arr);
assert(wrapper[2] == 2);
assert(arr == [1, 42, 2, 41, 3, 40, 4, 42, 9]);
assert(*wrapper[3 .. 6].ptr != null, [41, 3, 40]);
assert(arr == [1, 42, 2, 41, 3, 40, 4, 42, 9]);
}
//Test move functions.
{
int[] arr = [1, 42, 2, 41, 3, 40, 4, 42, 9];
auto wrapper = refRange(&arr);
auto t1 = wrapper.moveFront();
auto t2 = wrapper.moveBack();
wrapper.front = t2;
wrapper.back = t1;
assert(arr == [9, 42, 2, 41, 3, 40, 4, 42, 1]);
sort(wrapper.save);
assert(arr == [1, 2, 3, 4, 9, 40, 41, 42, 42]);
}
}
@system unittest
{
struct S
{
@property int front() @safe const pure nothrow { return 0; }
enum bool empty = false;
void popFront() @safe pure nothrow { }
@property auto save() @safe pure nothrow { return this; }
}
S s;
auto wrapper = refRange(&s);
static assert(isInfinite!(typeof(wrapper)));
}
@system unittest
{
class C
{
@property int front() @safe const pure nothrow { return 0; }
@property bool empty() @safe const pure nothrow { return false; }
void popFront() @safe pure nothrow { }
@property auto save() @safe pure nothrow { return this; }
}
static assert(isForwardRange!C);
auto c = new C;
auto cWrapper = refRange(&c);
static assert(is(typeof(cWrapper) == C));
assert(cWrapper is c);
}
@system unittest // issue 14373
{
static struct R
{
@property int front() {return 0;}
void popFront() {empty = true;}
bool empty = false;
}
R r;
refRange(&r).popFront();
assert(r.empty);
}
@system unittest // issue 14575
{
struct R
{
Object front;
alias back = front;
bool empty = false;
void popFront() {empty = true;}
alias popBack = popFront;
@property R save() {return this;}
}
static assert(isBidirectionalRange!R);
R r;
auto rr = refRange(&r);
struct R2
{
@property Object front() {return null;}
@property const(Object) front() const {return null;}
alias back = front;
bool empty = false;
void popFront() {empty = true;}
alias popBack = popFront;
@property R2 save() {return this;}
}
static assert(isBidirectionalRange!R2);
R2 r2;
auto rr2 = refRange(&r2);
}
/// ditto
auto refRange(R)(R* range)
if (isInputRange!R)
{
static if (!is(R == class))
return RefRange!R(range);
else
return *range;
}
/*****************************************************************************/
@safe unittest // bug 9060
{
import std.algorithm.iteration : map, joiner, group;
import std.algorithm.searching : until;
// fix for std.algorithm
auto r = map!(x => 0)([1]);
chain(r, r);
zip(r, r);
roundRobin(r, r);
struct NRAR {
typeof(r) input;
@property empty() { return input.empty; }
@property front() { return input.front; }
void popFront() { input.popFront(); }
@property save() { return NRAR(input.save); }
}
auto n1 = NRAR(r);
cycle(n1); // non random access range version
assumeSorted(r);
// fix for std.range
joiner([r], [9]);
struct NRAR2 {
NRAR input;
@property empty() { return true; }
@property front() { return input; }
void popFront() { }
@property save() { return NRAR2(input.save); }
}
auto n2 = NRAR2(n1);
joiner(n2);
group(r);
until(r, 7);
static void foo(R)(R r) { until!(x => x > 7)(r); }
foo(r);
}
private struct Bitwise(R)
if (isInputRange!R && isIntegral!(ElementType!R))
{
import std.traits : Unsigned;
private:
alias ElemType = ElementType!R;
alias UnsignedElemType = Unsigned!ElemType;
R parent;
enum bitsNum = ElemType.sizeof * 8;
size_t maskPos = 1;
static if (isBidirectionalRange!R)
{
size_t backMaskPos = bitsNum;
}
public:
this()(auto ref R range)
{
parent = range;
}
static if (isInfinite!R)
{
enum empty = false;
}
else
{
/**
* Check if the range is empty
*
* Returns: a boolean true or false
*/
bool empty()
{
static if (hasLength!R)
{
return length == 0;
}
else static if (isBidirectionalRange!R)
{
if (parent.empty)
{
return true;
}
else
{
/*
If we have consumed the last element of the range both from
the front and the back, then the masks positions will overlap
*/
return parent.save.dropOne.empty && (maskPos > backMaskPos);
}
}
else
{
/*
If we consumed the last element of the range, but not all the
bits in the last element
*/
return parent.empty;
}
}
}
bool front()
{
assert(!empty);
return (parent.front & mask(maskPos)) != 0;
}
void popFront()
{
assert(!empty);
++maskPos;
if (maskPos > bitsNum)
{
parent.popFront;
maskPos = 1;
}
}
static if (hasLength!R)
{
size_t length()
{
auto len = parent.length * bitsNum - (maskPos - 1);
static if (isBidirectionalRange!R)
{
len -= bitsNum - backMaskPos;
}
return len;
}
alias opDollar = length;
}
static if (isForwardRange!R)
{
typeof(this) save()
{
auto result = this;
result.parent = parent.save;
return result;
}
}
static if (isBidirectionalRange!R)
{
bool back()
{
assert(!empty);
return (parent.back & mask(backMaskPos)) != 0;
}
void popBack()
{
assert(!empty);
--backMaskPos;
if (backMaskPos == 0)
{
parent.popBack;
backMaskPos = bitsNum;
}
}
}
static if (isRandomAccessRange!R)
{
/**
Return the `n`th bit within the range
*/
bool opIndex(size_t n)
in
{
/*
If it does not have the length property, it means that R is
an infinite range
*/
static if (hasLength!R)
{
assert(n < length, "Index out of bounds");
}
}
do
{
immutable size_t remainingBits = bitsNum - maskPos + 1;
// If n >= maskPos, then the bit sign will be 1, otherwise 0
immutable ptrdiff_t sign = (remainingBits - n - 1) >> (ptrdiff_t.sizeof * 8 - 1);
/*
By truncating n with remainingBits bits we have skipped the
remaining bits in parent[0], so we need to add 1 to elemIndex.
Because bitsNum is a power of 2, n / bitsNum == n >> bitsNum.bsf
*/
import core.bitop : bsf;
immutable size_t elemIndex = sign * (((n - remainingBits) >> bitsNum.bsf) + 1);
/*
Since the indexing is from LSB to MSB, we need to index at the
remainder of (n - remainingBits).
Because bitsNum is a power of 2, n % bitsNum == n & (bitsNum - 1)
*/
immutable size_t elemMaskPos = (sign ^ 1) * (maskPos + n)
+ sign * (1 + ((n - remainingBits) & (bitsNum - 1)));
return (parent[elemIndex] & mask(elemMaskPos)) != 0;
}
static if (hasAssignableElements!R)
{
/**
Assigns `flag` to the `n`th bit within the range
*/
void opIndexAssign(bool flag, size_t n)
in
{
static if (hasLength!R)
{
assert(n < length, "Index out of bounds");
}
}
do
{
import core.bitop : bsf;
immutable size_t remainingBits = bitsNum - maskPos + 1;
immutable ptrdiff_t sign = (remainingBits - n - 1) >> (ptrdiff_t.sizeof * 8 - 1);
immutable size_t elemIndex = sign * (((n - remainingBits) >> bitsNum.bsf) + 1);
immutable size_t elemMaskPos = (sign ^ 1) * (maskPos + n)
+ sign * (1 + ((n - remainingBits) & (bitsNum - 1)));
auto elem = parent[elemIndex];
auto elemMask = mask(elemMaskPos);
parent[elemIndex] = cast(UnsignedElemType)(flag * (elem | elemMask)
+ (flag ^ 1) * (elem & ~elemMask));
}
}
Bitwise!R opSlice()
{
return this.save;
}
Bitwise!R opSlice(size_t start, size_t end)
in
{
assert(start < end, "Invalid bounds: end <= start");
}
do
{
import core.bitop : bsf;
size_t remainingBits = bitsNum - maskPos + 1;
ptrdiff_t sign = (remainingBits - start - 1) >> (ptrdiff_t.sizeof * 8 - 1);
immutable size_t startElemIndex = sign * (((start - remainingBits) >> bitsNum.bsf) + 1);
immutable size_t startElemMaskPos = (sign ^ 1) * (maskPos + start)
+ sign * (1 + ((start - remainingBits) & (bitsNum - 1)));
immutable size_t sliceLen = end - start - 1;
remainingBits = bitsNum - startElemMaskPos + 1;
sign = (remainingBits - sliceLen - 1) >> (ptrdiff_t.sizeof * 8 - 1);
immutable size_t endElemIndex = startElemIndex
+ sign * (((sliceLen - remainingBits) >> bitsNum.bsf) + 1);
immutable size_t endElemMaskPos = (sign ^ 1) * (startElemMaskPos + sliceLen)
+ sign * (1 + ((sliceLen - remainingBits) & (bitsNum - 1)));
typeof(return) result;
// Get the slice to be returned from the parent
result.parent = (parent[startElemIndex .. endElemIndex + 1]).save;
result.maskPos = startElemMaskPos;
static if (isBidirectionalRange!R)
{
result.backMaskPos = endElemMaskPos;
}
return result;
}
}
private:
auto mask(size_t maskPos)
{
return (1UL << (maskPos - 1UL));
}
}
/**
Bitwise adapter over an integral type range. Consumes the range elements bit by
bit, from the least significant bit to the most significant bit.
Params:
R = an integral $(REF_ALTTEXT input range, isInputRange, std,range,primitives) to iterate over
range = range to consume bit by by
Returns:
A `Bitwise` input range with propagated forward, bidirectional
and random access capabilities
*/
auto bitwise(R)(auto ref R range)
if (isInputRange!R && isIntegral!(ElementType!R))
{
return Bitwise!R(range);
}
///
@safe pure unittest
{
import std.algorithm.comparison : equal;
import std.format : format;
// 00000011 00001001
ubyte[] arr = [3, 9];
auto r = arr.bitwise;
// iterate through it as with any other range
assert(format("%(%d%)", r) == "1100000010010000");
assert(format("%(%d%)", r.retro).equal("1100000010010000".retro));
auto r2 = r[5 .. $];
// set a bit
r[2] = 1;
assert(arr[0] == 7);
assert(r[5] == r2[0]);
}
/// You can use bitwise to implement an uniform bool generator
@safe unittest
{
import std.algorithm.comparison : equal;
import std.random : rndGen;
auto rb = rndGen.bitwise;
static assert(isInfinite!(typeof(rb)));
auto rb2 = rndGen.bitwise;
// Don't forget that structs are passed by value
assert(rb.take(10).equal(rb2.take(10)));
}
// Test nogc inference
@safe @nogc unittest
{
static ubyte[] arr = [3, 9];
auto bw = arr.bitwise;
auto bw2 = bw[];
auto bw3 = bw[8 .. $];
bw3[2] = true;
assert(arr[1] == 13);
assert(bw[$ - 6]);
assert(bw[$ - 6] == bw2[$ - 6]);
assert(bw[$ - 6] == bw3[$ - 6]);
}
// Test all range types over all integral types
@safe pure nothrow unittest
{
import std.meta : AliasSeq;
import std.internal.test.dummyrange;
alias IntegralTypes = AliasSeq!(byte, ubyte, short, ushort, int, uint,
long, ulong);
foreach (IntegralType; IntegralTypes)
{
foreach (T; AllDummyRangesType!(IntegralType[]))
{
T a;
auto bw = Bitwise!T(a);
static if (isForwardRange!T)
{
auto bwFwdSave = bw.save;
}
static if (isBidirectionalRange!T)
{
auto bwBack = bw.save;
auto bwBackSave = bw.save;
}
static if (hasLength!T)
{
auto bwLength = bw.length;
assert(bw.length == (IntegralType.sizeof * 8 * a.length));
static if (isForwardRange!T)
{
assert(bw.length == bwFwdSave.length);
}
}
// Make sure front and back are not the mechanisms that modify the range
long numCalls = 42;
bool initialFrontValue;
if (!bw.empty)
{
initialFrontValue = bw.front;
}
while (!bw.empty && (--numCalls))
{
bw.front;
assert(bw.front == initialFrontValue);
}
/*
Check that empty works properly and that popFront does not get called
more times than it should
*/
numCalls = 0;
while (!bw.empty)
{
++numCalls;
static if (hasLength!T)
{
assert(bw.length == bwLength);
--bwLength;
}
static if (isForwardRange!T)
{
assert(bw.front == bwFwdSave.front);
bwFwdSave.popFront();
}
static if (isBidirectionalRange!T)
{
assert(bwBack.front == bwBackSave.front);
bwBack.popBack();
bwBackSave.popBack();
}
bw.popFront();
}
auto rangeLen = numCalls / (IntegralType.sizeof * 8);
assert(numCalls == (IntegralType.sizeof * 8 * rangeLen));
assert(bw.empty);
static if (isForwardRange!T)
{
assert(bwFwdSave.empty);
}
static if (isBidirectionalRange!T)
{
assert(bwBack.empty);
}
}
}
}
// Test opIndex and opSlice
@system unittest
{
import std.meta : AliasSeq;
alias IntegralTypes = AliasSeq!(byte, ubyte, short, ushort, int, uint,
long, ulong);
foreach (IntegralType; IntegralTypes)
{
size_t bitsNum = IntegralType.sizeof * 8;
auto first = cast(IntegralType)(1);
// 2 ^ (bitsNum - 1)
auto second = cast(IntegralType)(cast(IntegralType)(1) << (bitsNum - 2));
IntegralType[] a = [first, second];
auto bw = Bitwise!(IntegralType[])(a);
// Check against lsb of a[0]
assert(bw[0] == true);
// Check against msb - 1 of a[1]
assert(bw[2 * bitsNum - 2] == true);
bw.popFront();
assert(bw[2 * bitsNum - 3] == true);
import std.exception : assertThrown;
// Check out of bounds error
assertThrown!Error(bw[2 * bitsNum - 1]);
bw[2] = true;
assert(bw[2] == true);
bw.popFront();
assert(bw[1] == true);
auto bw2 = bw[0 .. $ - 5];
auto bw3 = bw2[];
assert(bw2.length == (bw.length - 5));
assert(bw2.length == bw3.length);
bw2.popFront();
assert(bw2.length != bw3.length);
}
}
/*********************************
* An OutputRange that discards the data it receives.
*/
struct NullSink
{
void put(E)(scope const E) pure @safe @nogc nothrow {}
}
/// ditto
auto ref nullSink()
{
static NullSink sink;
return sink;
}
///
@safe nothrow unittest
{
import std.algorithm.iteration : map;
import std.algorithm.mutation : copy;
[4, 5, 6].map!(x => x * 2).copy(nullSink); // data is discarded
}
///
@safe unittest
{
import std.csv : csvNextToken;
string line = "a,b,c";
// ignore the first column
line.csvNextToken(nullSink, ',', '"');
line.popFront;
// look at the second column
Appender!string app;
line.csvNextToken(app, ',', '"');
assert(app.data == "b");
}
@safe unittest
{
auto r = 10.iota
.tee(nullSink)
.dropOne;
assert(r.front == 1);
}
/++
Implements a "tee" style pipe, wrapping an input range so that elements of the
range can be passed to a provided function or $(LREF OutputRange) as they are
iterated over. This is useful for printing out intermediate values in a long
chain of range code, performing some operation with side-effects on each call
to `front` or `popFront`, or diverting the elements of a range into an
auxiliary $(LREF OutputRange).
It is important to note that as the resultant range is evaluated lazily,
in the case of the version of `tee` that takes a function, the function
will not actually be executed until the range is "walked" using functions
that evaluate ranges, such as $(REF array, std,array) or
$(REF fold, std,algorithm,iteration).
Params:
pipeOnPop = If `Yes.pipeOnPop`, simply iterating the range without ever
calling `front` is enough to have `tee` mirror elements to `outputRange` (or,
respectively, `fun`). If `No.pipeOnPop`, only elements for which `front` does
get called will be also sent to `outputRange`/`fun`.
inputRange = The input range being passed through.
outputRange = This range will receive elements of `inputRange` progressively
as iteration proceeds.
fun = This function will be called with elements of `inputRange`
progressively as iteration proceeds.
Returns:
An input range that offers the elements of `inputRange`. Regardless of
whether `inputRange` is a more powerful range (forward, bidirectional etc),
the result is always an input range. Reading this causes `inputRange` to be
iterated and returns its elements in turn. In addition, the same elements
will be passed to `outputRange` or `fun` as well.
See_Also: $(REF each, std,algorithm,iteration)
+/
auto tee(Flag!"pipeOnPop" pipeOnPop = Yes.pipeOnPop, R1, R2)(R1 inputRange, R2 outputRange)
if (isInputRange!R1 && isOutputRange!(R2, ElementType!R1))
{
static struct Result
{
private R1 _input;
private R2 _output;
static if (!pipeOnPop)
{
private bool _frontAccessed;
}
static if (hasLength!R1)
{
@property auto length()
{
return _input.length;
}
}
static if (isInfinite!R1)
{
enum bool empty = false;
}
else
{
@property bool empty() { return _input.empty; }
}
void popFront()
{
assert(!_input.empty, "Attempting to popFront an empty tee");
static if (pipeOnPop)
{
put(_output, _input.front);
}
else
{
_frontAccessed = false;
}
_input.popFront();
}
@property auto ref front()
{
assert(!_input.empty, "Attempting to fetch the front of an empty tee");
static if (!pipeOnPop)
{
if (!_frontAccessed)
{
_frontAccessed = true;
put(_output, _input.front);
}
}
return _input.front;
}
}
return Result(inputRange, outputRange);
}
/// Ditto
auto tee(alias fun, Flag!"pipeOnPop" pipeOnPop = Yes.pipeOnPop, R1)(R1 inputRange)
if (is(typeof(fun) == void) || isSomeFunction!fun)
{
import std.traits : isDelegate, isFunctionPointer;
/*
Distinguish between function literals and template lambdas
when using either as an $(LREF OutputRange). Since a template
has no type, typeof(template) will always return void.
If it's a template lambda, it's first necessary to instantiate
it with `ElementType!R1`.
*/
static if (is(typeof(fun) == void))
alias _fun = fun!(ElementType!R1);
else
alias _fun = fun;
static if (isFunctionPointer!_fun || isDelegate!_fun)
{
return tee!pipeOnPop(inputRange, _fun);
}
else
{
return tee!pipeOnPop(inputRange, &_fun);
}
}
///
@safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filter, map;
// Sum values while copying
int[] values = [1, 4, 9, 16, 25];
int sum = 0;
auto newValues = values.tee!(a => sum += a).array;
assert(equal(newValues, values));
assert(sum == 1 + 4 + 9 + 16 + 25);
// Count values that pass the first filter
int count = 0;
auto newValues4 = values.filter!(a => a < 10)
.tee!(a => count++)
.map!(a => a + 1)
.filter!(a => a < 10);
//Fine, equal also evaluates any lazy ranges passed to it.
//count is not 3 until equal evaluates newValues4
assert(equal(newValues4, [2, 5]));
assert(count == 3);
}
//
@safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filter, map;
int[] values = [1, 4, 9, 16, 25];
int count = 0;
auto newValues = values.filter!(a => a < 10)
.tee!(a => count++, No.pipeOnPop)
.map!(a => a + 1)
.filter!(a => a < 10);
auto val = newValues.front;
assert(count == 1);
//front is only evaluated once per element
val = newValues.front;
assert(count == 1);
//popFront() called, fun will be called
//again on the next access to front
newValues.popFront();
newValues.front;
assert(count == 2);
int[] preMap = new int[](3), postMap = [];
auto mappedValues = values.filter!(a => a < 10)
//Note the two different ways of using tee
.tee(preMap)
.map!(a => a + 1)
.tee!(a => postMap ~= a)
.filter!(a => a < 10);
assert(equal(mappedValues, [2, 5]));
assert(equal(preMap, [1, 4, 9]));
assert(equal(postMap, [2, 5, 10]));
}
//
@safe unittest
{
import std.algorithm.comparison : equal;
import std.algorithm.iteration : filter, map;
char[] txt = "Line one, Line 2".dup;
bool isVowel(dchar c)
{
import std.string : indexOf;
return "AaEeIiOoUu".indexOf(c) != -1;
}
int vowelCount = 0;
int shiftedCount = 0;
auto removeVowels = txt.tee!(c => isVowel(c) ? vowelCount++ : 0)
.filter!(c => !isVowel(c))
.map!(c => (c == ' ') ? c : c + 1)
.tee!(c => isVowel(c) ? shiftedCount++ : 0);
assert(equal(removeVowels, "Mo o- Mo 3"));
assert(vowelCount == 6);
assert(shiftedCount == 3);
}
@safe unittest
{
// Manually stride to test different pipe behavior.
void testRange(Range)(Range r)
{
const int strideLen = 3;
int i = 0;
ElementType!Range elem1;
ElementType!Range elem2;
while (!r.empty)
{
if (i % strideLen == 0)
{
//Make sure front is only
//evaluated once per item
elem1 = r.front;
elem2 = r.front;
assert(elem1 == elem2);
}
r.popFront();
i++;
}
}
string txt = "abcdefghijklmnopqrstuvwxyz";
int popCount = 0;
auto pipeOnPop = txt.tee!(a => popCount++);
testRange(pipeOnPop);
assert(popCount == 26);
int frontCount = 0;
auto pipeOnFront = txt.tee!(a => frontCount++, No.pipeOnPop);
testRange(pipeOnFront);
assert(frontCount == 9);
}
@safe unittest
{
import std.algorithm.comparison : equal;
import std.meta : AliasSeq;
//Test diverting elements to an OutputRange
string txt = "abcdefghijklmnopqrstuvwxyz";
dchar[] asink1 = [];
auto fsink = (dchar c) { asink1 ~= c; };
auto result1 = txt.tee(fsink).array;
assert(equal(txt, result1) && (equal(result1, asink1)));
dchar[] _asink1 = [];
auto _result1 = txt.tee!((dchar c) { _asink1 ~= c; })().array;
assert(equal(txt, _result1) && (equal(_result1, _asink1)));
dchar[] asink2 = new dchar[](txt.length);
void fsink2(dchar c) { static int i = 0; asink2[i] = c; i++; }
auto result2 = txt.tee(&fsink2).array;
assert(equal(txt, result2) && equal(result2, asink2));
dchar[] asink3 = new dchar[](txt.length);
auto result3 = txt.tee(asink3).array;
assert(equal(txt, result3) && equal(result3, asink3));
static foreach (CharType; AliasSeq!(char, wchar, dchar))
{{
auto appSink = appender!(CharType[])();
auto appResult = txt.tee(appSink).array;
assert(equal(txt, appResult) && equal(appResult, appSink.data));
}}
static foreach (StringType; AliasSeq!(string, wstring, dstring))
{{
auto appSink = appender!StringType();
auto appResult = txt.tee(appSink).array;
assert(equal(txt, appResult) && equal(appResult, appSink.data));
}}
}
@safe unittest
{
// Issue 13483
static void func1(T)(T x) {}
void func2(int x) {}
auto r = [1, 2, 3, 4].tee!func1.tee!func2;
}
/**
Extends the length of the input range `r` by padding out the start of the
range with the element `e`. The element `e` must be of a common type with
the element type of the range `r` as defined by $(REF CommonType, std, traits).
If `n` is less than the length of of `r`, then `r` is returned unmodified.
If `r` is a string with Unicode characters in it, `padLeft` follows D's rules
about length for strings, which is not the number of characters, or
graphemes, but instead the number of encoding units. If you want to treat each
grapheme as only one encoding unit long, then call
$(REF byGrapheme, std, uni) before calling this function.
If `r` has a length, then this is $(BIGOH 1). Otherwise, it's $(BIGOH r.length).
Params:
r = an $(REF_ALTTEXT input range, isInputRange, std,range,primitives) with a length, or a forward range
e = element to pad the range with
n = the length to pad to
Returns:
A range containing the elements of the original range with the extra padding
See Also:
$(REF leftJustifier, std, string)
*/
auto padLeft(R, E)(R r, E e, size_t n)
if (
((isInputRange!R && hasLength!R) || isForwardRange!R) &&
!is(CommonType!(ElementType!R, E) == void)
)
{
static if (hasLength!R)
auto dataLength = r.length;
else
auto dataLength = r.save.walkLength(n);
return e.repeat(n > dataLength ? n - dataLength : 0).chain(r);
}
///
@safe pure unittest
{
import std.algorithm.comparison : equal;
assert([1, 2, 3, 4].padLeft(0, 6).equal([0, 0, 1, 2, 3, 4]));
assert([1, 2, 3, 4].padLeft(0, 3).equal([1, 2, 3, 4]));
assert("abc".padLeft('_', 6).equal("___abc"));
}
@safe pure nothrow unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : DummyRange, Length, RangeType, ReturnBy;
import std.meta : AliasSeq;
alias DummyRanges = AliasSeq!(
DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Input),
DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Forward),
DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Bidirectional),
DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Random),
DummyRange!(ReturnBy.Reference, Length.No, RangeType.Forward),
DummyRange!(ReturnBy.Value, Length.Yes, RangeType.Input),
DummyRange!(ReturnBy.Value, Length.Yes, RangeType.Forward),
DummyRange!(ReturnBy.Value, Length.Yes, RangeType.Bidirectional),
DummyRange!(ReturnBy.Value, Length.Yes, RangeType.Random),
DummyRange!(ReturnBy.Value, Length.No, RangeType.Forward)
);
foreach (Range; DummyRanges)
{
Range r;
assert(r
.padLeft(0, 12)
.equal([0, 0, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U])
);
}
}
// Test nogc inference
@safe @nogc pure unittest
{
import std.algorithm.comparison : equal;
static immutable r1 = [1, 2, 3, 4];
static immutable r2 = [0, 0, 1, 2, 3, 4];
assert(r1.padLeft(0, 6).equal(r2));
}
/**
Extend the length of the input range `r` by padding out the end of the range
with the element `e`. The element `e` must be of a common type with the
element type of the range `r` as defined by $(REF CommonType, std, traits).
If `n` is less than the length of of `r`, then the contents of `r` are
returned.
The range primitives that the resulting range provides depends whether or not `r`
provides them. Except the functions `back` and `popBack`, which also require
the range to have a length as well as `back` and `popBack`
Params:
r = an $(REF_ALTTEXT input range, isInputRange, std,range,primitives) with a length
e = element to pad the range with
n = the length to pad to
Returns:
A range containing the elements of the original range with the extra padding
See Also:
$(REF rightJustifier, std, string)
*/
auto padRight(R, E)(R r, E e, size_t n)
if (
isInputRange!R &&
!isInfinite!R &&
!is(CommonType!(ElementType!R, E) == void))
{
static struct Result
{
private:
R data;
E element;
static if (hasLength!R)
{
size_t padLength;
}
else
{
size_t minLength;
size_t consumed;
}
public:
bool empty() @property
{
static if (hasLength!R)
{
return data.empty && padLength == 0;
}
else
{
return data.empty && consumed >= minLength;
}
}
auto front() @property
{
assert(!empty, "Attempting to fetch the front of an empty padRight");
return data.empty ? element : data.front;
}
void popFront()
{
assert(!empty, "Attempting to popFront an empty padRight");
static if (hasLength!R)
{
if (!data.empty)
{
data.popFront;
}
else
{
--padLength;
}
}
else
{
++consumed;
if (!data.empty)
{
data.popFront;
}
}
}
static if (hasLength!R)
{
size_t length() @property
{
return data.length + padLength;
}
}
static if (isForwardRange!R)
{
auto save() @property
{
typeof(this) result = this;
data = data.save;
return result;
}
}
static if (isBidirectionalRange!R && hasLength!R)
{
auto back() @property
{
assert(!empty, "Attempting to fetch the back of an empty padRight");
return padLength > 0 ? element : data.back;
}
void popBack()
{
assert(!empty, "Attempting to popBack an empty padRight");
if (padLength > 0)
{
--padLength;
}
else
{
data.popBack;
}
}
}
static if (isRandomAccessRange!R && hasLength!R)
{
E opIndex(size_t index)
{
assert(index <= this.length, "Index out of bounds");
return index >= data.length ? element : data[index];
}
}
static if (hasSlicing!R && hasLength!R)
{
auto opSlice(size_t a, size_t b)
{
assert(
a <= b,
"Attempting to slice a padRight with a larger first argument than the second."
);
assert(
b <= length,
"Attempting to slice using an out of bounds index on a padRight"
);
return Result(
a >= data.length ? data[0 .. 0] : b <= data.length ? data[a .. b] : data[a .. data.length],
element, b - a);
}
alias opDollar = length;
}
this(R r, E e, size_t n)
{
data = r;
element = e;
static if (hasLength!R)
{
padLength = n > data.length ? n - data.length : 0;
}
else
{
minLength = n;
}
}
@disable this();
}
return Result(r, e, n);
}
///
@safe pure unittest
{
import std.algorithm.comparison : equal;
assert([1, 2, 3, 4].padRight(0, 6).equal([1, 2, 3, 4, 0, 0]));
assert([1, 2, 3, 4].padRight(0, 4).equal([1, 2, 3, 4]));
assert("abc".padRight('_', 6).equal("abc___"));
}
pure @safe unittest
{
import std.algorithm.comparison : equal;
import std.internal.test.dummyrange : AllDummyRanges, ReferenceInputRange;
import std.meta : AliasSeq;
auto string_input_range = new ReferenceInputRange!dchar(['a', 'b', 'c']);
dchar padding = '_';
assert(string_input_range.padRight(padding, 6).equal("abc___"));
foreach (RangeType; AllDummyRanges)
{
RangeType r1;
assert(r1
.padRight(0, 12)
.equal([1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 0, 0])
);
// test if Result properly uses random access ranges
static if (isRandomAccessRange!RangeType)
{
RangeType r3;
assert(r3.padRight(0, 12)[0] == 1);
assert(r3.padRight(0, 12)[2] == 3);
assert(r3.padRight(0, 12)[9] == 10);
assert(r3.padRight(0, 12)[10] == 0);
assert(r3.padRight(0, 12)[11] == 0);
}
// test if Result properly uses slicing and opDollar
static if (hasSlicing!RangeType)
{
RangeType r4;
assert(r4
.padRight(0, 12)[0 .. 3]
.equal([1, 2, 3])
);
assert(r4
.padRight(0, 12)[0 .. 10]
.equal([1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U])
);
assert(r4
.padRight(0, 12)[0 .. 11]
.equal([1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 0])
);
assert(r4
.padRight(0, 12)[2 .. $]
.equal([3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 0, 0])
);
assert(r4
.padRight(0, 12)[0 .. $]
.equal([1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 0, 0])
);
}
// drop & dropBack test opslice ranges when available, popFront/popBack otherwise
RangeType r5;
foreach (i; 1 .. 13) assert(r5.padRight(0, 12).drop(i).walkLength == 12 - i);
}
}
// Test nogc inference
@safe @nogc pure unittest
{
import std.algorithm.comparison : equal;
static immutable r1 = [1, 2, 3, 4];
static immutable r2 = [1, 2, 3, 4, 0, 0];
assert(r1.padRight(0, 6).equal(r2));
}
// Test back, popBack, and save
@safe pure unittest
{
import std.algorithm.comparison : equal;
auto r1 = [1, 2, 3, 4].padRight(0, 6);
assert(r1.back == 0);
r1.popBack;
auto r2 = r1.save;
assert(r1.equal([1, 2, 3, 4, 0]));
assert(r2.equal([1, 2, 3, 4, 0]));
r1.popBackN(2);
assert(r1.back == 3);
assert(r1.length == 3);
assert(r2.length == 5);
assert(r2.equal([1, 2, 3, 4, 0]));
r2.popFront;
assert(r2.length == 4);
assert(r2[0] == 2);
assert(r2[1] == 3);
assert(r2[2] == 4);
assert(r2[3] == 0);
assert(r2.equal([2, 3, 4, 0]));
r2.popBack;
assert(r2.equal([2, 3, 4]));
auto r3 = [1, 2, 3, 4].padRight(0, 6);
size_t len = 0;
while (!r3.empty)
{
++len;
r3.popBack;
}
assert(len == 6);
}
// Issue 19042
@safe pure unittest
{
import std.algorithm.comparison : equal;
assert([2, 5, 13].padRight(42, 10).chunks(5)
.equal!equal([[2, 5, 13, 42, 42], [42, 42, 42, 42, 42]]));
assert([1, 2, 3, 4].padRight(0, 10)[7 .. 9].equal([0, 0]));
}
|
D
|
/Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/TemplateKit.build/AST/TemplateEmbed.swift.o : /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateData.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateEmbed.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Deprecated.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateSource.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateDataStorage.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/ASTCache.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateDataRepresentable.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Utilities/HTMLEscape.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateSyntaxType.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Uppercase.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Lowercase.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Capitalize.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateTag.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateConditional.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateCustom.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateExpression.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Var.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateDataEncoder.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateIdentifier.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateByteScanner.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/TagRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/PlaintextRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/ViewRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateParser.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateSerializer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Utilities/TemplateError.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateIterator.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Contains.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Utilities/Exports.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/DateFormat.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateConstant.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Comment.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Print.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Count.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateDataContext.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/TagContext.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Raw.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateRaw.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/View.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateSyntax.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/NIO.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Async.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Service.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Core.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Debugging.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Bits.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/cpp_magic.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOLinux/include/ifaddrs-android.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIODarwin/include/CNIODarwin.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/CNIOAtomics.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOLinux/include/CNIOLinux.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOSHA1.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOOpenSSL.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CCryptoOpenSSL.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOZlib.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIODarwin.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOHTTPParser.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOAtomics.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOLinux.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio-zlib-support/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/ApplicationServices.framework/Headers/ApplicationServices.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/TemplateKit.build/AST/TemplateEmbed~partial.swiftmodule : /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateData.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateEmbed.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Deprecated.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateSource.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateDataStorage.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/ASTCache.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateDataRepresentable.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Utilities/HTMLEscape.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateSyntaxType.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Uppercase.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Lowercase.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Capitalize.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateTag.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateConditional.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateCustom.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateExpression.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Var.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateDataEncoder.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateIdentifier.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateByteScanner.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/TagRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/PlaintextRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/ViewRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateParser.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateSerializer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Utilities/TemplateError.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateIterator.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Contains.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Utilities/Exports.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/DateFormat.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateConstant.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Comment.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Print.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Count.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateDataContext.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/TagContext.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Raw.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateRaw.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/View.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateSyntax.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/NIO.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Async.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Service.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Core.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Debugging.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Bits.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/cpp_magic.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOLinux/include/ifaddrs-android.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIODarwin/include/CNIODarwin.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/CNIOAtomics.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOLinux/include/CNIOLinux.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOSHA1.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOOpenSSL.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CCryptoOpenSSL.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOZlib.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIODarwin.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOHTTPParser.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOAtomics.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOLinux.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio-zlib-support/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/ApplicationServices.framework/Headers/ApplicationServices.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/TemplateKit.build/AST/TemplateEmbed~partial.swiftdoc : /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateData.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateEmbed.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Deprecated.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateSource.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateDataStorage.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/ASTCache.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateDataRepresentable.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Utilities/HTMLEscape.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateSyntaxType.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Uppercase.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Lowercase.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Capitalize.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateTag.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateConditional.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateCustom.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateExpression.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Var.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Data/TemplateDataEncoder.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateIdentifier.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateByteScanner.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/TagRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/PlaintextRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/ViewRenderer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateParser.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Pipeline/TemplateSerializer.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Utilities/TemplateError.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateIterator.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Contains.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Utilities/Exports.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/DateFormat.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateConstant.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Comment.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Print.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Count.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateDataContext.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/TagContext.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/Tag/Raw.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateRaw.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/View.swift /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/template-kit/Sources/TemplateKit/AST/TemplateSyntax.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/NIO.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Async.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Service.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Core.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Debugging.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/Bits.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/cpp_magic.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOLinux/include/ifaddrs-android.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIODarwin/include/CNIODarwin.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/CNIOAtomics.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio/Sources/CNIOLinux/include/CNIOLinux.h /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOSHA1.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOOpenSSL.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CCryptoOpenSSL.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOZlib.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIODarwin.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOHTTPParser.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOAtomics.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/x86_64-apple-macosx/debug/CNIOLinux.build/module.modulemap /Users/mhassanin/Developer/CupcakeVapor/CupcakeCorner/.build/checkouts/swift-nio-zlib-support/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/ApplicationServices.framework/Headers/ApplicationServices.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
|
D
|
/Users/shawngong/Centa/.build/debug/Console.build/Bar/Loading/Console+LoadingBar.swift.o : /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Bar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Argument.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Command+Print.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Command.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Group.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Option.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Runnable.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Value.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Ask.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Center.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Confirm.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Options.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Print.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Run.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/ConsoleError.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Stream/FileHandle+Stream.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Stream/Pipe+Stream.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Stream/Stream.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/ConsoleColor+Terminal.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/ConsoleStyle+Terminal.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/String+ANSI.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/Terminal+Command.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/Terminal.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Utilities/Bool+Polymorphic.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Utilities/String+Trim.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Loading/Console+LoadingBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Loading/LoadingBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Progress/Console+ProgressBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Progress/ProgressBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Clear/ConsoleClear.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Color/ConsoleColor.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Style/Console+ConsoleStyle.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Style/ConsoleStyle.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/shawngong/Centa/.build/debug/libc.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Users/shawngong/Centa/.build/debug/Polymorphic.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Users/shawngong/Centa/.build/debug/CLibreSSL.build/module.modulemap /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Users/shawngong/Centa/.build/debug/Core.swiftmodule
/Users/shawngong/Centa/.build/debug/Console.build/Console+LoadingBar~partial.swiftmodule : /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Bar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Argument.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Command+Print.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Command.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Group.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Option.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Runnable.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Value.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Ask.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Center.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Confirm.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Options.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Print.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Run.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/ConsoleError.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Stream/FileHandle+Stream.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Stream/Pipe+Stream.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Stream/Stream.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/ConsoleColor+Terminal.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/ConsoleStyle+Terminal.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/String+ANSI.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/Terminal+Command.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/Terminal.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Utilities/Bool+Polymorphic.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Utilities/String+Trim.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Loading/Console+LoadingBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Loading/LoadingBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Progress/Console+ProgressBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Progress/ProgressBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Clear/ConsoleClear.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Color/ConsoleColor.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Style/Console+ConsoleStyle.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Style/ConsoleStyle.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/shawngong/Centa/.build/debug/libc.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Users/shawngong/Centa/.build/debug/Polymorphic.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Users/shawngong/Centa/.build/debug/CLibreSSL.build/module.modulemap /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Users/shawngong/Centa/.build/debug/Core.swiftmodule
/Users/shawngong/Centa/.build/debug/Console.build/Console+LoadingBar~partial.swiftdoc : /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Bar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Argument.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Command+Print.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Command.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Group.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Option.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Runnable.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Command/Value.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Ask.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Center.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Confirm.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Options.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Print.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console+Run.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Console.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/ConsoleError.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Stream/FileHandle+Stream.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Stream/Pipe+Stream.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Stream/Stream.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/ConsoleColor+Terminal.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/ConsoleStyle+Terminal.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/String+ANSI.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/Terminal+Command.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Terminal/Terminal.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Utilities/Bool+Polymorphic.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Utilities/String+Trim.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Loading/Console+LoadingBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Loading/LoadingBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Progress/Console+ProgressBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Bar/Progress/ProgressBar.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Clear/ConsoleClear.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Color/ConsoleColor.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Style/Console+ConsoleStyle.swift /Users/shawngong/Centa/Packages/Console-1.0.2/Sources/Console/Console/Style/ConsoleStyle.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/shawngong/Centa/.build/debug/libc.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Users/shawngong/Centa/.build/debug/Polymorphic.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Users/shawngong/Centa/.build/debug/CLibreSSL.build/module.modulemap /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Users/shawngong/Centa/.build/debug/Core.swiftmodule
|
D
|
/Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/Service/RevertCommand.swift.o : /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/ID.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Model+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/Deprecated.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/MigrateCommand.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/RevertCommand.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Decode.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Range.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/SoftDeletable.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Aggregate.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationConfig.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Join/JoinSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Transaction/TransactionSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Query/QuerySupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationLog.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Model.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Model.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/AnyModel.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Children.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Join/QueryBuilder+Join.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting+Migration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/Migration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/AnyMigration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Run.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/FluentProvider.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaBuilder.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaUpdater.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Filter.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/FluentError.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaCreator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/DatabasesConfig+References.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Siblings.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/Migrations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/AnyMigrations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Operators.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/Exports.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Parent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/CommandConfig+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Cache/KeyedCacheSupporting+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Database/DatabaseConnection+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/ModelEvent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Pivot.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Sort.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Copy.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Cache/CacheEntry.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Query/FluentProperty.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/XPC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Combine.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Swift.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/IOKit.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-macos.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/cpp_magic.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/ifaddrs-android.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIODarwin/include/CNIODarwin.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/CNIOAtomics.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/CNIOLinux.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOSHA1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOHTTP1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/MySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentMySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CCryptoOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/HTTP.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOTLS.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOZlib.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOPriorityQueue.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Routing.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Random.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/URLEncodedForm.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIODarwin.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Authentication.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Crypto.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/App.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOHTTPParser.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Vapor.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOAtomics.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/WebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOWebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/TemplateKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Multipart.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOLinux.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio-zlib-support/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/xpc/XPC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/ApplicationServices.framework/Headers/ApplicationServices.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/Service/RevertCommand~partial.swiftmodule : /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/ID.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Model+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/Deprecated.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/MigrateCommand.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/RevertCommand.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Decode.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Range.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/SoftDeletable.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Aggregate.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationConfig.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Join/JoinSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Transaction/TransactionSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Query/QuerySupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationLog.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Model.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Model.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/AnyModel.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Children.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Join/QueryBuilder+Join.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting+Migration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/Migration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/AnyMigration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Run.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/FluentProvider.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaBuilder.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaUpdater.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Filter.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/FluentError.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaCreator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/DatabasesConfig+References.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Siblings.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/Migrations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/AnyMigrations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Operators.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/Exports.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Parent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/CommandConfig+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Cache/KeyedCacheSupporting+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Database/DatabaseConnection+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/ModelEvent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Pivot.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Sort.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Copy.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Cache/CacheEntry.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Query/FluentProperty.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/XPC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Combine.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Swift.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/IOKit.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-macos.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/cpp_magic.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/ifaddrs-android.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIODarwin/include/CNIODarwin.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/CNIOAtomics.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/CNIOLinux.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOSHA1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOHTTP1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/MySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentMySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CCryptoOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/HTTP.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOTLS.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOZlib.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOPriorityQueue.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Routing.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Random.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/URLEncodedForm.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIODarwin.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Authentication.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Crypto.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/App.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOHTTPParser.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Vapor.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOAtomics.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/WebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOWebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/TemplateKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Multipart.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOLinux.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio-zlib-support/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/xpc/XPC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/ApplicationServices.framework/Headers/ApplicationServices.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/Service/RevertCommand~partial.swiftdoc : /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/ID.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Model+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/Deprecated.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/MigrateCommand.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/RevertCommand.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Decode.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Range.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/SoftDeletable.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Aggregate.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationConfig.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Join/JoinSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Transaction/TransactionSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Query/QuerySupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationLog.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Model.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Model.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/AnyModel.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Children.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Join/QueryBuilder+Join.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting+Migration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/Migration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/AnyMigration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Run.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/FluentProvider.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaBuilder.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaUpdater.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Filter.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/FluentError.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaCreator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/DatabasesConfig+References.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Siblings.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/Migrations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/AnyMigrations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Operators.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/Exports.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Parent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/CommandConfig+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Cache/KeyedCacheSupporting+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Database/DatabaseConnection+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/ModelEvent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Pivot.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Sort.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Copy.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Cache/CacheEntry.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Query/FluentProperty.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/XPC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Combine.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Swift.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/IOKit.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-macos.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/cpp_magic.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/ifaddrs-android.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIODarwin/include/CNIODarwin.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/CNIOAtomics.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/CNIOLinux.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOSHA1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOHTTP1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/MySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentMySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CCryptoOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/HTTP.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOTLS.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOZlib.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOPriorityQueue.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Routing.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Random.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/URLEncodedForm.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIODarwin.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Authentication.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Crypto.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/App.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOHTTPParser.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Vapor.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOAtomics.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/WebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOWebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/TemplateKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Multipart.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOLinux.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio-zlib-support/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/xpc/XPC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/ApplicationServices.framework/Headers/ApplicationServices.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/Service/RevertCommand~partial.swiftsourceinfo : /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/ID.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Model+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+CRUD.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/Deprecated.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/MigrateCommand.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/RevertCommand.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Decode.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Range.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/SoftDeletable.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Aggregate.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationConfig.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Join/JoinSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Transaction/TransactionSupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Query/QuerySupporting.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/MigrationLog.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Model.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Model.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/AnyModel.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Children.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Join/QueryBuilder+Join.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaSupporting+Migration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/Migration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/AnyMigration.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Run.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/FluentProvider.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaBuilder.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaUpdater.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Filter.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/FluentError.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/SchemaCreator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Schema/DatabasesConfig+References.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Siblings.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/Migrations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Migration/AnyMigrations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Operators.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Utilities/Exports.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Relations/Parent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Service/CommandConfig+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Cache/KeyedCacheSupporting+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Database/DatabaseConnection+Fluent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/ModelEvent.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Model/Pivot.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Sort.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/QueryBuilder/QueryBuilder+Copy.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Cache/CacheEntry.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/fluent/Sources/Fluent/Query/FluentProperty.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/XPC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Combine.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Swift.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/IOKit.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-macos.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/cpp_magic.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/ifaddrs-android.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIODarwin/include/CNIODarwin.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/CNIOAtomics.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/CNIOLinux.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOSHA1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOHTTP1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/MySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentMySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CCryptoOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/HTTP.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOTLS.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOZlib.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOPriorityQueue.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Routing.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Random.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/URLEncodedForm.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIODarwin.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Authentication.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Crypto.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/App.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOHTTPParser.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Vapor.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOAtomics.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/WebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOWebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/TemplateKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Multipart.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOLinux.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio-zlib-support/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/xpc/XPC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/ApplicationServices.framework/Headers/ApplicationServices.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
|
D
|
PLONG PLAT ED95 KD LOMAGAGE HIMAGAGE SLAT SLONG RESULTNO DP DM ROCKTYPE
303.5 77.1999969 2.79999995 89.6999969 10 14 -38.7000008 143.100006 139 4.19999981 4.19999981 sediments, limestone
289.600006 75.1999969 1.79999995 73.1999969 11 19 -31.6000004 145.600006 9338 2.5 2.5 sediments, saprolite
294.399994 82.9000015 1.89999998 472.299988 8 23 -33.5999985 150.600006 1154 2.0999999 2.79999995 sediments
236.600006 78.5 0 7.5 0 35 -17.2000008 131.5 1894 0 0 sediments, red mudstones
270.5 80.4000015 0 125 5 23 -32.5 138.5 1976 8.39999962 8.39999962 sediments, red clays
256.899994 86.9000015 0 88 5 23 -36 137 1974 8.39999962 8.39999962 sediments, weathered
246 79.4000015 0 0 15 20 -32 150 1924 4.19999981 4.19999981 extrusives, basalts
|
D
|
/**
* Copyright: (c) 2005-2009 Eric Poggel
* Authors: Eric Poggel
* License: <a href="lgpl3.txt">LGPL v3</a>
*/
module yage.core.types;
import tango.stdc.string : memcpy;
import tango.math.Math;
import yage.core.math.math;
import yage.core.math.vector:Vec4f;
/**
* Allow for easy bit-by-bit conversion from one two-byte type to another.
* Example:
* --------------------------------
* short s = word("Hi").s; // the bits of the string "Hi" are stored in s.
* ubyte[] u = word(512).ub; // u[0] is 0 and u[1] is 1.
* --------------------------------
*/
struct word
{
union
{ short s; /// Get the word as one of these types.
ushort us; /// ditto
byte[2] b; /// ditto
ubyte[2] ub; /// ditto
char[2] c; /// ditto
}
/// Convert to word
static word opCall(T)(T i)
{ word res;
memcpy(&res.s, &i, min(2, T.sizeof));
return res;
}
unittest
{ assert(word.sizeof == 2);
assert(word(3).s == 3);
assert(word("Hi").c == "Hi");
assert(word(3).us == word(word(1).s + word(2).s).us);
}
}
/// Allow for easy bit-by-bit conversion from one four-byte type to another
struct dword
{ union
{ int i; /// Get the dword as one of these types.
uint ui; /// ditto
float f; /// ditto
short[2] s; /// ditto
ushort[2] us; /// ditto
word[2] w; /// ditto
byte[4] b; /// ditto
ubyte[4] ub; /// ditto
char[4] c; /// ditto
}
/// Convert to dword
static dword opCall(T)(T i)
{ dword res;
memcpy(&res.i, &i, min(4, T.sizeof));
return res;
}
unittest
{ assert(dword.sizeof == 4);
assert(dword(3.0f).f == 3.0f);
assert(dword("l33t").c == "l33t");
assert(dword(3.0f).i == dword(dword(1.0f).f + dword(2.0f).f).i);
}
}
/// Allow for easy bit-by-bit conversion from one eight-byte type to another.
union qword
{ long l; /// Get the qword as one of these types
ulong ul; /// ditto
double d; /// ditto
float[2] f; /// ditto
int[2] i; /// ditto
uint[2] ui; /// ditto
dword[2] dw; /// ditto
short[4] s; /// ditto
ushort[4] us; /// ditto
word[4] w; /// ditto
byte[8] b; /// ditto
ubyte[8] ub; /// ditto
char[8] c; /// ditto
/// Convert to qword
static qword opCall(T)(T i)
{ qword res;
memcpy(&res.l, &i, min(8, T.sizeof));
return res;
}
unittest
{ assert(qword.sizeof == 8);
assert(qword(3L).l == 3L);
assert(qword("yageyage").c == "yageyage");
assert(qword(3.0).l == qword(qword(1.0).d + qword(2.0).d).l);
}
}
|
D
|
import util;
import expression; // : Node, Identifier
import semantic, scope_;
import std.algorithm, std.range, std.conv, std.string:join;
import std.typecons : Tuple, tuple;
import hashtable;
// TODO: make the Scheduler understand all parties that currently make use of
// Identifier.tryAgain. Then get rid of Identifier.tryAgain
class Scheduler{
void add(Node root, Scope sc){
workingset.add(root, sc);
}
final void remove(Node node){
workingset.remove(node);
}
final void await(Node from, Node to, Scope sc)in{assert(from !is to);}body{
// dw("from ", from, " to ", to);
workingset.await(from, to, sc);
}
struct WorkingSet{
private enum useBuiltin = true;
static if(useBuiltin) private template Map(K, V){ alias V[K] Map; }
else private template Map(K,V){ alias HashMap!(K, V, "a is b","cast(size_t)cast(void*)a/16") Map; }
Map!(Node,Scope) active;
Map!(Node,Scope) asleep;
Map!(Node,Node[]) awaited;
Map!(Node,bool) done;
Map!(Node,Scope) payload;
void add(Node node, Scope sc) {
if(node in asleep) return;
active[node]=sc;
}
void remove(Node node) {
done[node] = true;
// dw("done with: ",node);
active.remove(node);
asleep.remove(node);
foreach(v; awaited.get(node,[])){
if(v !in asleep) continue; // TODO: why needed?
Identifier.tryAgain = true;
auto sc=asleep[v];
active[v]=sc;
asleep.remove(v);
}
awaited.remove(node);
}
void await(Node from, Node to, Scope sc){
awaited[to]~=from;
if(from !in active) return;
if(from in asleep) return;
asleep[from]=active[from]; // ...
active.remove(from);
add(to,sc);
}
void awake()in{assert(!active.length);}body{
// tarjan's algorithm
static struct Info{
uint index;
uint lowlink;
uint component = -1;
bool instack = false;
}
Info[Node] info;
uint index = 0;
uint component = 0;
Node[] stack;
void push(Node n){
stack~=n;
info[n].instack=true;
}
Node pop(){
auto n=stack[$-1];
stack=stack[0..$-1];
stack.assumeSafeAppend();
info[n].instack=false;
return n;
}
void tarjan(Node n){
info[n]=Info(index, index);
index++;
push(n);
foreach(x;awaited.get(n,[])){
// if(x !in asleep) continue; // TODO: why can this happen?
if(x !in info){
tarjan(x);
info[n].lowlink = min(info[n].lowlink, info[x].lowlink);
}else if(info[x].instack){
info[n].lowlink = min(info[n].lowlink, info[x].index);
}
}
if(info[n].index==info[n].lowlink){
Node x;
do{
x = pop();
assert(info[x].component == -1);
info[x].component = component;
}while(x !is n);
component++;
}
}
foreach(n,_; asleep) if(n !in info) tarjan(n);
/+auto nodes = asleep.keys;
foreach(i;0..component){
write("component ",i,": [");
foreach(x;nodes)
if(info[x].component==i) write(x,",");
writeln("]");
}+/
// TODO: this is unnecessary because tarjan output is ordered
bool[] bad = new bool[component];
foreach(dependee,_; asleep){
foreach(dependent; awaited.get(dependee,[])){
// if(dependent !in asleep) continue; // TODO: why can this happen?
if(info[dependee].component == info[dependent].component) continue;
bad[info[dependent].component] = true;
}
}
Node[] toRemove;
// TODO: only awaken those nodes that reside inside is-expressions if there are any
foreach(nd,sc; asleep){
if(bad[info[nd].component]) continue;
active[nd]=sc;
toRemove~=nd;
}
foreach(nd; toRemove) asleep.remove(nd);
update();
//dw("no hope!");
//foreach(nd,sc;payload) dw(nd);
foreach(nd,sc; payload) nd.noHope(sc);
update();
}
void update(){
// dw("active: ",active.keys);
// dw("asleep: ",asleep.keys);
foreach(nd,sc; active){
if(nd.sstate == SemState.completed && !nd.needRetry
|| nd.sstate == SemState.error || nd.rewrite)
done[nd] = true;
}
foreach(nd,b; done) active.remove(nd);
payload = active.dup();
assert({foreach(nd,sc;payload) assert(!nd.rewrite,text(nd)); return 1;}());
done.clear(); assert(!done.length);
}
void buildInterface(){
assert(0); // TODO!
}
void semantic(){
//dw(payload);
foreach(nd,sc; payload){
// this code causes very significant slowdowns for deeply nested template instantiations and often is a bottleneck for template meta-programs
// TODO: optimize or find a way to ensure correctness that does not depend on this
TemplateInstanceDecl[] tmpls; // TODO: use a SmallCollection, or just a counter
import declaration;
for(auto tmpl=nd.isDeclaration().and((cast(Declaration)cast(void*)nd).isTemplateInstanceDecl().maybe!(a=>a.instantiation.isSymbol().maybe!(a=>a.scope_))).or(sc).maybe!(a=>a.getTemplateInstance());
tmpl&&tmpl.sstate==SemState.begin;
tmpl=tmpl.instantiation.isSymbol()
.maybe!(a=>a.scope_.maybe!(a=>a.getTemplateInstance()))
// TODO: there is no clear reason why the maybe's might work!
){
tmpl.sstate = SemState.started;
tmpls~=tmpl;
}
scope(exit) foreach(tmpl;tmpls) tmpl.sstate = SemState.begin;
/////////////////////////////////////////////////////////////////////////////////////////
// dw("analyzing ",nd," ",nd.sstate," ",nd.needRetry," ",!!nd.rewrite, " ",nd.loc,tmpls);
//if(sc) dw("inst",sc," ", sc.getTemplateInstance());
if(nd.sstate == SemState.completed){
if(nd.needRetry){
if(auto exp=nd.isExpression()) exp.interpret(sc);
}else remove(nd);
continue;
}else if(nd.sstate == SemState.error) remove(nd);
nd.semantic(sc);
assert(nd.needRetry != 2,text(nd.toString()," ",nd.loc));
assert(!Symbol.circ);
//assert(nd.sstate != SemState.started, text(nd, " ", nd.loc," ", typeid(nd)));
//dw("done with ",nd," ",nd.sstate," ",nd.needRetry," ",!!nd.rewrite," ",tmpls);
}
update();
}
}
WorkingSet workingset;
void run(){
mixin(Configure!q{Identifier.tryAgain = true});
mixin(Configure!q{Identifier.allowDelay = true});
workingset.update();
do{
// dw("starting resolution pass");
Identifier.tryAgain = true;
do{
Identifier.tryAgain = false;
workingset.semantic();
}while(Identifier.tryAgain);
// dw("starting kill pass");
Identifier.allowDelay=false;
workingset.semantic();
Identifier.allowDelay=true;
//dw("workingset: ",map!(_=>text(_," ",_.sstate," ",typeid(_)))(workingset.payload.keys));
// dw(workingset.payload.length);
// dw(workingset.asleep.keys,"\n\n\n",workingset.awaited);
if(!workingset.payload.length&&workingset.asleep.length)
workingset.awake();
}while(workingset.payload.length);
// dw(champ," ",champ.cccc);
}
static Scheduler opCall(){
static Scheduler instance;
return instance?instance:(instance=new Scheduler);
}
}
|
D
|
/Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Intermediates.noindex/Delivry.build/Debug-iphonesimulator/Delivry.build/Objects-normal/x86_64/paymentScreenViewController.o : /Users/Benjamin/Desktop/Delivry/Delivry/ResetPassword/ResetPassword.swift /Users/Benjamin/Desktop/Delivry/Delivry/New\ Group/GooglePlace.swift /Users/Benjamin/Desktop/Delivry/Delivry/BackendBridge/BackendBridge.swift /Users/Benjamin/Desktop/Delivry/Delivry/MainScreenOne/MainScreenOne.swift /Users/Benjamin/Desktop/Delivry/Delivry/CourierScreen/DriverMainScreenOne.swift /Users/Benjamin/Desktop/Delivry/Delivry/AppDelegate.swift /Users/Benjamin/Desktop/Delivry/Delivry/PickupConfirmationScreen/PickupConfirmationScreen.swift /Users/Benjamin/Desktop/Delivry/Delivry/MainScreenTwo/MainScreenTwo.swift /Users/Benjamin/Desktop/Delivry/Delivry/New\ Group/GoogleDataProvider.swift /Users/Benjamin/Desktop/Delivry/Delivry/LogIn/LoginController.swift /Users/Benjamin/Desktop/Delivry/Delivry/SignUp/SignUpController.swift /Users/Benjamin/Desktop/Delivry/Delivry/AdvancedSearch/advancedSearchViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/PlaceScreen/placeScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/HomeScreen/homeScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/OrderScreen/OrderScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/PendingOrderScreen/pendingOrderScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/AccountScreen/settingsScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/PaymentScreen/paymentScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/About/aboutScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/MenuScreen/menuScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/OrderHistoryScreen/orderHistoryScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/OrderSuccessScreen/orderSuccessViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/DeliveryAddress/deliveryAddressViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/Utils/Methods.swift /Users/Benjamin/Desktop/Delivry/Delivry/Utils/Constants\ and\ Global\ Variables.swift /Users/Benjamin/Desktop/Delivry/Delivry/Utils/Extensions.swift /Users/Benjamin/Desktop/Delivry/Delivry/APIClient/MyAPIClient.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotesc /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Modules/SwiftyJSON.swiftmodule/x86_64.swiftmodule /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/Alamofire.swiftmodule/x86_64.swiftmodule /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Modules/SideMenu.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreLocation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Contacts.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Headers/SwiftyJSON-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/Stripe-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Headers/SideMenu-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanorama.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaCamera.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacePhotoMetadata.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentCardTextField.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardBrand.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentMethod.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPApplePayPaymentMethod.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlaceLikelihood.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCard.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlace.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSUserAddedPlace.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaService.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSource.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaSource.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteTableDataSource.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteBoundsMode.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAPIResponseDecodable.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPFormEncodable.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCircle.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPFile.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapStyle.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPTheme.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/UINavigationBar+Stripe_Theme.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPolyline.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/Stripe.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GoogleMapsBase.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCameraUpdate.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaCameraUpdate.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardValidationState.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GMSPlacePickerConfig.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSIndoorBuilding.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPath.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMutablePath.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaLink.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSIndoorLevel.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceProtocol.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPToken.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPolygon.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceVerification.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapView+Animation.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPUserInformation.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentConfiguration.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSOrientation.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSProjection.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompletePrediction.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCameraPosition.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPEphemeralKeyProvider.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSGeocoder.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteFetcher.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GMSPlacePicker.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GooglePlacePicker.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMarker.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAddCardViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCoreTableViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCoreViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCoreScrollViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GMSPlacePickerViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentMethodsViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPShippingAddressViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteResultsViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCustomer.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceOwner.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteFilter.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBackendAPIAdapter.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceReceiver.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCALayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSURLTileLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSTileLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSSyncTileLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMarkerLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSOverlayLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/StripeError.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardValidator.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GMSCoordinateBounds.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GooglePlaces.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSServices.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlaceTypes.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSUISettings.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBlocks.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceCardDetails.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceSEPADebitDetails.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSGeometryUtils.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentIntentParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBankAccountParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPConnectAccountParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPLegalEntityParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceEnums.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentIntentEnums.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/FauxPasAnnotations.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GMSDeprecationMacros.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GMSCompatabilityMacros.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCoordinateBounds+GoogleMaps.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GoogleMaps.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacesErrors.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAddress.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSAddress.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceRedirect.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Headers/SwiftyJSON-Swift.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-Swift.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Headers/SideMenu-Swift.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentResult.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAPIClient.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacesClient.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteMatchFragment.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAddressComponent.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentIntent.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBankAccount.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacePhotoMetadataList.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlaceLikelihoodList.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCustomerContext.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPRedirectContext.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentContext.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaView.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapView.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentActivityIndicatorView.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAPIClient+ApplePay.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSIndoorDisplay.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSOverlay.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSGroundOverlay.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPImageLibrary.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreLocation.framework/Headers/CoreLocation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/Contacts.framework/Headers/Contacts.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/WebKit.framework/Headers/WebKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/PassKit.framework/Headers/PassKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes
/Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Intermediates.noindex/Delivry.build/Debug-iphonesimulator/Delivry.build/Objects-normal/x86_64/paymentScreenViewController~partial.swiftmodule : /Users/Benjamin/Desktop/Delivry/Delivry/ResetPassword/ResetPassword.swift /Users/Benjamin/Desktop/Delivry/Delivry/New\ Group/GooglePlace.swift /Users/Benjamin/Desktop/Delivry/Delivry/BackendBridge/BackendBridge.swift /Users/Benjamin/Desktop/Delivry/Delivry/MainScreenOne/MainScreenOne.swift /Users/Benjamin/Desktop/Delivry/Delivry/CourierScreen/DriverMainScreenOne.swift /Users/Benjamin/Desktop/Delivry/Delivry/AppDelegate.swift /Users/Benjamin/Desktop/Delivry/Delivry/PickupConfirmationScreen/PickupConfirmationScreen.swift /Users/Benjamin/Desktop/Delivry/Delivry/MainScreenTwo/MainScreenTwo.swift /Users/Benjamin/Desktop/Delivry/Delivry/New\ Group/GoogleDataProvider.swift /Users/Benjamin/Desktop/Delivry/Delivry/LogIn/LoginController.swift /Users/Benjamin/Desktop/Delivry/Delivry/SignUp/SignUpController.swift /Users/Benjamin/Desktop/Delivry/Delivry/AdvancedSearch/advancedSearchViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/PlaceScreen/placeScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/HomeScreen/homeScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/OrderScreen/OrderScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/PendingOrderScreen/pendingOrderScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/AccountScreen/settingsScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/PaymentScreen/paymentScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/About/aboutScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/MenuScreen/menuScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/OrderHistoryScreen/orderHistoryScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/OrderSuccessScreen/orderSuccessViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/DeliveryAddress/deliveryAddressViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/Utils/Methods.swift /Users/Benjamin/Desktop/Delivry/Delivry/Utils/Constants\ and\ Global\ Variables.swift /Users/Benjamin/Desktop/Delivry/Delivry/Utils/Extensions.swift /Users/Benjamin/Desktop/Delivry/Delivry/APIClient/MyAPIClient.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotesc /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Modules/SwiftyJSON.swiftmodule/x86_64.swiftmodule /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/Alamofire.swiftmodule/x86_64.swiftmodule /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Modules/SideMenu.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreLocation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Contacts.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Headers/SwiftyJSON-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/Stripe-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Headers/SideMenu-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanorama.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaCamera.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacePhotoMetadata.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentCardTextField.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardBrand.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentMethod.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPApplePayPaymentMethod.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlaceLikelihood.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCard.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlace.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSUserAddedPlace.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaService.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSource.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaSource.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteTableDataSource.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteBoundsMode.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAPIResponseDecodable.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPFormEncodable.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCircle.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPFile.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapStyle.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPTheme.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/UINavigationBar+Stripe_Theme.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPolyline.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/Stripe.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GoogleMapsBase.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCameraUpdate.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaCameraUpdate.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardValidationState.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GMSPlacePickerConfig.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSIndoorBuilding.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPath.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMutablePath.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaLink.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSIndoorLevel.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceProtocol.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPToken.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPolygon.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceVerification.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapView+Animation.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPUserInformation.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentConfiguration.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSOrientation.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSProjection.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompletePrediction.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCameraPosition.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPEphemeralKeyProvider.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSGeocoder.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteFetcher.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GMSPlacePicker.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GooglePlacePicker.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMarker.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAddCardViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCoreTableViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCoreViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCoreScrollViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GMSPlacePickerViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentMethodsViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPShippingAddressViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteResultsViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCustomer.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceOwner.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteFilter.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBackendAPIAdapter.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceReceiver.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCALayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSURLTileLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSTileLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSSyncTileLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMarkerLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSOverlayLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/StripeError.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardValidator.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GMSCoordinateBounds.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GooglePlaces.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSServices.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlaceTypes.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSUISettings.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBlocks.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceCardDetails.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceSEPADebitDetails.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSGeometryUtils.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentIntentParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBankAccountParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPConnectAccountParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPLegalEntityParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceEnums.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentIntentEnums.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/FauxPasAnnotations.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GMSDeprecationMacros.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GMSCompatabilityMacros.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCoordinateBounds+GoogleMaps.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GoogleMaps.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacesErrors.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAddress.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSAddress.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceRedirect.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Headers/SwiftyJSON-Swift.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-Swift.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Headers/SideMenu-Swift.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentResult.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAPIClient.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacesClient.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteMatchFragment.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAddressComponent.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentIntent.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBankAccount.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacePhotoMetadataList.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlaceLikelihoodList.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCustomerContext.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPRedirectContext.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentContext.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaView.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapView.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentActivityIndicatorView.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAPIClient+ApplePay.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSIndoorDisplay.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSOverlay.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSGroundOverlay.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPImageLibrary.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreLocation.framework/Headers/CoreLocation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/Contacts.framework/Headers/Contacts.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/WebKit.framework/Headers/WebKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/PassKit.framework/Headers/PassKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes
/Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Intermediates.noindex/Delivry.build/Debug-iphonesimulator/Delivry.build/Objects-normal/x86_64/paymentScreenViewController~partial.swiftdoc : /Users/Benjamin/Desktop/Delivry/Delivry/ResetPassword/ResetPassword.swift /Users/Benjamin/Desktop/Delivry/Delivry/New\ Group/GooglePlace.swift /Users/Benjamin/Desktop/Delivry/Delivry/BackendBridge/BackendBridge.swift /Users/Benjamin/Desktop/Delivry/Delivry/MainScreenOne/MainScreenOne.swift /Users/Benjamin/Desktop/Delivry/Delivry/CourierScreen/DriverMainScreenOne.swift /Users/Benjamin/Desktop/Delivry/Delivry/AppDelegate.swift /Users/Benjamin/Desktop/Delivry/Delivry/PickupConfirmationScreen/PickupConfirmationScreen.swift /Users/Benjamin/Desktop/Delivry/Delivry/MainScreenTwo/MainScreenTwo.swift /Users/Benjamin/Desktop/Delivry/Delivry/New\ Group/GoogleDataProvider.swift /Users/Benjamin/Desktop/Delivry/Delivry/LogIn/LoginController.swift /Users/Benjamin/Desktop/Delivry/Delivry/SignUp/SignUpController.swift /Users/Benjamin/Desktop/Delivry/Delivry/AdvancedSearch/advancedSearchViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/PlaceScreen/placeScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/HomeScreen/homeScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/OrderScreen/OrderScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/PendingOrderScreen/pendingOrderScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/AccountScreen/settingsScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/PaymentScreen/paymentScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/About/aboutScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/MenuScreen/menuScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/OrderHistoryScreen/orderHistoryScreenViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/OrderSuccessScreen/orderSuccessViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/DeliveryAddress/deliveryAddressViewController.swift /Users/Benjamin/Desktop/Delivry/Delivry/Utils/Methods.swift /Users/Benjamin/Desktop/Delivry/Delivry/Utils/Constants\ and\ Global\ Variables.swift /Users/Benjamin/Desktop/Delivry/Delivry/Utils/Extensions.swift /Users/Benjamin/Desktop/Delivry/Delivry/APIClient/MyAPIClient.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotesc /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Modules/SwiftyJSON.swiftmodule/x86_64.swiftmodule /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/Alamofire.swiftmodule/x86_64.swiftmodule /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Modules/SideMenu.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreLocation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Contacts.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Headers/SwiftyJSON-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/Stripe-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Headers/SideMenu-umbrella.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanorama.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaCamera.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacePhotoMetadata.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentCardTextField.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardBrand.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentMethod.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPApplePayPaymentMethod.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlaceLikelihood.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCard.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlace.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSUserAddedPlace.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaService.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSource.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaSource.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteTableDataSource.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteBoundsMode.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAPIResponseDecodable.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPFormEncodable.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCircle.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPFile.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapStyle.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPTheme.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/UINavigationBar+Stripe_Theme.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPolyline.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/Stripe.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GoogleMapsBase.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCameraUpdate.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaCameraUpdate.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardValidationState.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GMSPlacePickerConfig.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSIndoorBuilding.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPath.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMutablePath.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaLink.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSIndoorLevel.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceProtocol.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPToken.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPolygon.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceVerification.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapView+Animation.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPUserInformation.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentConfiguration.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSOrientation.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSProjection.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompletePrediction.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCameraPosition.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPEphemeralKeyProvider.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSGeocoder.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteFetcher.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GMSPlacePicker.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GooglePlacePicker.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMarker.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAddCardViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCoreTableViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCoreViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCoreScrollViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Headers/GMSPlacePickerViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentMethodsViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPShippingAddressViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteResultsViewController.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCustomer.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceOwner.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteFilter.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBackendAPIAdapter.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceReceiver.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCALayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSURLTileLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSTileLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSSyncTileLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMarkerLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSOverlayLayer.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/StripeError.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardValidator.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GMSCoordinateBounds.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GooglePlaces.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSServices.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlaceTypes.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSUISettings.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBlocks.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceCardDetails.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceSEPADebitDetails.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSGeometryUtils.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCardParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentIntentParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBankAccountParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPConnectAccountParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPLegalEntityParams.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceEnums.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentIntentEnums.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/FauxPasAnnotations.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GMSDeprecationMacros.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Headers/GMSCompatabilityMacros.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSCoordinateBounds+GoogleMaps.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GoogleMaps.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacesErrors.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAddress.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSAddress.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPSourceRedirect.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Headers/SwiftyJSON-Swift.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-Swift.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Headers/SideMenu-Swift.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentResult.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAPIClient.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacesClient.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAutocompleteMatchFragment.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSAddressComponent.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentIntent.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPBankAccount.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlacePhotoMetadataList.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Headers/GMSPlaceLikelihoodList.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPCustomerContext.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPRedirectContext.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentContext.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSPanoramaView.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSMapView.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPPaymentActivityIndicatorView.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPAPIClient+ApplePay.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSIndoorDisplay.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSOverlay.h /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Headers/GMSGroundOverlay.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Headers/STPImageLibrary.h /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SwiftyJSON/SwiftyJSON.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Stripe/Stripe.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Base/Frameworks/GoogleMapsBase.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlacePicker/Frameworks/GooglePlacePicker.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GooglePlaces/Frameworks/GooglePlaces.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/Pods/GoogleMaps/Maps/Frameworks/GoogleMaps.framework/Modules/module.modulemap /Users/Benjamin/Desktop/Delivry/Delivry/DerivedData/Delivry/Build/Products/Debug-iphonesimulator/SideMenu/SideMenu.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreLocation.framework/Headers/CoreLocation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/Contacts.framework/Headers/Contacts.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/WebKit.framework/Headers/WebKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/PassKit.framework/Headers/PassKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator11.4.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes
|
D
|
module wx.Event;
public import wx.common;
typedef int EventType;
//! \cond EXTERN
static extern (C) EventType wxEvent_GetEventType(IntPtr self);
static extern (C) int wxEvent_GetId(IntPtr self);
static extern (C) bool wxEvent_GetSkipped(IntPtr self);
static extern (C) int wxEvent_GetTimestamp(IntPtr self);
static extern (C) void wxEvent_Skip(IntPtr self, bool skip);
static extern (C) IntPtr wxEvent_GetEventObject(IntPtr self);
static extern (C) void wxEvent_SetEventObject(IntPtr self, IntPtr object);
//---------------------------------------------------------------------
static extern (C) EventType wxEvent_EVT_NULL();
static extern (C) EventType wxEvent_EVT_IDLE();
static extern (C) EventType wxEvent_EVT_SOCKET();
static extern (C) EventType wxEvent_EVT_COMMAND_BUTTON_CLICKED();
static extern (C) EventType wxEvent_EVT_COMMAND_CHECKBOX_CLICKED();
static extern (C) EventType wxEvent_EVT_COMMAND_CHOICE_SELECTED();
static extern (C) EventType wxEvent_EVT_COMMAND_LISTBOX_SELECTED();
static extern (C) EventType wxEvent_EVT_COMMAND_LISTBOX_DOUBLECLICKED();
static extern (C) EventType wxEvent_EVT_COMMAND_CHECKLISTBOX_TOGGLED();
static extern (C) EventType wxEvent_EVT_COMMAND_TEXT_UPDATED();
static extern (C) EventType wxEvent_EVT_COMMAND_TEXT_ENTER();
static extern (C) EventType wxEvent_EVT_COMMAND_TEXT_URL();
static extern (C) EventType wxEvent_EVT_COMMAND_TEXT_MAXLEN();
static extern (C) EventType wxEvent_EVT_COMMAND_MENU_SELECTED();
static extern (C) EventType wxEvent_EVT_COMMAND_SLIDER_UPDATED();
static extern (C) EventType wxEvent_EVT_COMMAND_RADIOBOX_SELECTED();
static extern (C) EventType wxEvent_EVT_COMMAND_RADIOBUTTON_SELECTED();
static extern (C) EventType wxEvent_EVT_COMMAND_SCROLLBAR_UPDATED();
static extern (C) EventType wxEvent_EVT_COMMAND_VLBOX_SELECTED();
static extern (C) EventType wxEvent_EVT_COMMAND_COMBOBOX_SELECTED();
static extern (C) EventType wxEvent_EVT_COMMAND_TOOL_RCLICKED();
static extern (C) EventType wxEvent_EVT_COMMAND_TOOL_ENTER();
static extern (C) EventType wxEvent_EVT_COMMAND_SPINCTRL_UPDATED();
// Sockets and timers send events, too
static extern (C) EventType wxEvent_EVT_TIMER ();
// Mouse event types
static extern (C) EventType wxEvent_EVT_LEFT_DOWN();
static extern (C) EventType wxEvent_EVT_LEFT_UP();
static extern (C) EventType wxEvent_EVT_MIDDLE_DOWN();
static extern (C) EventType wxEvent_EVT_MIDDLE_UP();
static extern (C) EventType wxEvent_EVT_RIGHT_DOWN();
static extern (C) EventType wxEvent_EVT_RIGHT_UP();
static extern (C) EventType wxEvent_EVT_MOTION();
static extern (C) EventType wxEvent_EVT_ENTER_WINDOW();
static extern (C) EventType wxEvent_EVT_LEAVE_WINDOW();
static extern (C) EventType wxEvent_EVT_LEFT_DCLICK();
static extern (C) EventType wxEvent_EVT_MIDDLE_DCLICK();
static extern (C) EventType wxEvent_EVT_RIGHT_DCLICK();
static extern (C) EventType wxEvent_EVT_SET_FOCUS();
static extern (C) EventType wxEvent_EVT_KILL_FOCUS();
static extern (C) EventType wxEvent_EVT_CHILD_FOCUS();
static extern (C) EventType wxEvent_EVT_MOUSEWHEEL();
// Non-client mouse events
static extern (C) EventType wxEvent_EVT_NC_LEFT_DOWN();
static extern (C) EventType wxEvent_EVT_NC_LEFT_UP();
static extern (C) EventType wxEvent_EVT_NC_MIDDLE_DOWN();
static extern (C) EventType wxEvent_EVT_NC_MIDDLE_UP();
static extern (C) EventType wxEvent_EVT_NC_RIGHT_DOWN();
static extern (C) EventType wxEvent_EVT_NC_RIGHT_UP();
static extern (C) EventType wxEvent_EVT_NC_MOTION();
static extern (C) EventType wxEvent_EVT_NC_ENTER_WINDOW();
static extern (C) EventType wxEvent_EVT_NC_LEAVE_WINDOW();
static extern (C) EventType wxEvent_EVT_NC_LEFT_DCLICK();
static extern (C) EventType wxEvent_EVT_NC_MIDDLE_DCLICK();
static extern (C) EventType wxEvent_EVT_NC_RIGHT_DCLICK();
// Character input event type
static extern (C) EventType wxEvent_EVT_CHAR();
static extern (C) EventType wxEvent_EVT_CHAR_HOOK();
static extern (C) EventType wxEvent_EVT_NAVIGATION_KEY();
static extern (C) EventType wxEvent_EVT_KEY_DOWN();
static extern (C) EventType wxEvent_EVT_KEY_UP();
version(wxUSE_HOTKEY)
{
static extern (C) EventType wxEvent_EVT_HOTKEY();
}
// Set cursor event
static extern (C) EventType wxEvent_EVT_SET_CURSOR();
// wxScrollbar and wxSlider event identifiers
static extern (C) EventType wxEvent_EVT_SCROLL_TOP();
static extern (C) EventType wxEvent_EVT_SCROLL_BOTTOM();
static extern (C) EventType wxEvent_EVT_SCROLL_LINEUP();
static extern (C) EventType wxEvent_EVT_SCROLL_LINEDOWN();
static extern (C) EventType wxEvent_EVT_SCROLL_PAGEUP();
static extern (C) EventType wxEvent_EVT_SCROLL_PAGEDOWN();
static extern (C) EventType wxEvent_EVT_SCROLL_THUMBTRACK();
static extern (C) EventType wxEvent_EVT_SCROLL_THUMBRELEASE();
static extern (C) EventType wxEvent_EVT_SCROLL_ENDSCROLL();
// Scroll events from wxWindow
static extern (C) EventType wxEvent_EVT_SCROLLWIN_TOP();
static extern (C) EventType wxEvent_EVT_SCROLLWIN_BOTTOM();
static extern (C) EventType wxEvent_EVT_SCROLLWIN_LINEUP();
static extern (C) EventType wxEvent_EVT_SCROLLWIN_LINEDOWN();
static extern (C) EventType wxEvent_EVT_SCROLLWIN_PAGEUP();
static extern (C) EventType wxEvent_EVT_SCROLLWIN_PAGEDOWN();
static extern (C) EventType wxEvent_EVT_SCROLLWIN_THUMBTRACK();
static extern (C) EventType wxEvent_EVT_SCROLLWIN_THUMBRELEASE();
// System events
static extern (C) EventType wxEvent_EVT_SIZE();
static extern (C) EventType wxEvent_EVT_SIZING();
static extern (C) EventType wxEvent_EVT_MOVE();
static extern (C) EventType wxEvent_EVT_MOVING();
static extern (C) EventType wxEvent_EVT_CLOSE_WINDOW();
static extern (C) EventType wxEvent_EVT_END_SESSION();
static extern (C) EventType wxEvent_EVT_QUERY_END_SESSION();
static extern (C) EventType wxEvent_EVT_ACTIVATE_APP();
static extern (C) EventType wxEvent_EVT_POWER();
static extern (C) EventType wxEvent_EVT_ACTIVATE();
static extern (C) EventType wxEvent_EVT_CREATE();
static extern (C) EventType wxEvent_EVT_DESTROY();
static extern (C) EventType wxEvent_EVT_SHOW();
static extern (C) EventType wxEvent_EVT_ICONIZE();
static extern (C) EventType wxEvent_EVT_MAXIMIZE();
static extern (C) EventType wxEvent_EVT_MOUSE_CAPTURE_CHANGED();
static extern (C) EventType wxEvent_EVT_PAINT();
static extern (C) EventType wxEvent_EVT_ERASE_BACKGROUND();
static extern (C) EventType wxEvent_EVT_NC_PAINT();
static extern (C) EventType wxEvent_EVT_PAINT_ICON();
static extern (C) EventType wxEvent_EVT_MENU_OPEN();
static extern (C) EventType wxEvent_EVT_MENU_CLOSE();
static extern (C) EventType wxEvent_EVT_MENU_HIGHLIGHT();
static extern (C) EventType wxEvent_EVT_CONTEXT_MENU();
static extern (C) EventType wxEvent_EVT_SYS_COLOUR_CHANGED();
static extern (C) EventType wxEvent_EVT_DISPLAY_CHANGED();
static extern (C) EventType wxEvent_EVT_SETTING_CHANGED();
static extern (C) EventType wxEvent_EVT_QUERY_NEW_PALETTE();
static extern (C) EventType wxEvent_EVT_PALETTE_CHANGED();
static extern (C) EventType wxEvent_EVT_JOY_BUTTON_DOWN();
static extern (C) EventType wxEvent_EVT_JOY_BUTTON_UP();
static extern (C) EventType wxEvent_EVT_JOY_MOVE();
static extern (C) EventType wxEvent_EVT_JOY_ZMOVE();
static extern (C) EventType wxEvent_EVT_DROP_FILES();
static extern (C) EventType wxEvent_EVT_DRAW_ITEM();
static extern (C) EventType wxEvent_EVT_MEASURE_ITEM();
static extern (C) EventType wxEvent_EVT_COMPARE_ITEM();
static extern (C) EventType wxEvent_EVT_INIT_DIALOG();
static extern (C) EventType wxEvent_EVT_UPDATE_UI();
// Generic command events
// Note: a click is a higher-level event than button down/up
static extern (C) EventType wxEvent_EVT_COMMAND_LEFT_CLICK();
static extern (C) EventType wxEvent_EVT_COMMAND_LEFT_DCLICK();
static extern (C) EventType wxEvent_EVT_COMMAND_RIGHT_CLICK();
static extern (C) EventType wxEvent_EVT_COMMAND_RIGHT_DCLICK();
static extern (C) EventType wxEvent_EVT_COMMAND_SET_FOCUS();
static extern (C) EventType wxEvent_EVT_COMMAND_KILL_FOCUS();
static extern (C) EventType wxEvent_EVT_COMMAND_ENTER();
// Help events
static extern (C) EventType wxEvent_EVT_HELP();
static extern (C) EventType wxEvent_EVT_DETAILED_HELP();
//togglebtn
static extern (C) EventType wxEvent_EVT_COMMAND_TOGGLEBUTTON_CLICKED();
static extern (C) EventType wxEvent_EVT_OBJECTDELETED();
// calendar control
static extern (C) EventType wxEvent_EVT_CALENDAR_SEL_CHANGED();
static extern (C) EventType wxEvent_EVT_CALENDAR_DAY_CHANGED();
static extern (C) EventType wxEvent_EVT_CALENDAR_MONTH_CHANGED();
static extern (C) EventType wxEvent_EVT_CALENDAR_YEAR_CHANGED();
static extern (C) EventType wxEvent_EVT_CALENDAR_DOUBLECLICKED();
static extern (C) EventType wxEvent_EVT_CALENDAR_WEEKDAY_CLICKED();
// find_replace
static extern (C) EventType wxEvent_EVT_COMMAND_FIND();
static extern (C) EventType wxEvent_EVT_COMMAND_FIND_NEXT();
static extern (C) EventType wxEvent_EVT_COMMAND_FIND_REPLACE();
static extern (C) EventType wxEvent_EVT_COMMAND_FIND_REPLACE_ALL();
static extern (C) EventType wxEvent_EVT_COMMAND_FIND_CLOSE();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_BEGIN_DRAG();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_BEGIN_RDRAG();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_BEGIN_LABEL_EDIT();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_END_LABEL_EDIT();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_DELETE_ITEM();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_GET_INFO();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_SET_INFO();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_ITEM_EXPANDED();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_ITEM_EXPANDING();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_ITEM_COLLAPSED();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_ITEM_COLLAPSING();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_SEL_CHANGED();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_SEL_CHANGING();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_KEY_DOWN();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_ITEM_ACTIVATED();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_ITEM_RIGHT_CLICK();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_ITEM_MIDDLE_CLICK();
static extern (C) EventType wxEvent_EVT_COMMAND_TREE_END_DRAG();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_BEGIN_DRAG();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_BEGIN_RDRAG();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_BEGIN_LABEL_EDIT();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_END_LABEL_EDIT();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_DELETE_ITEM();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_DELETE_ALL_ITEMS();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_GET_INFO();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_SET_INFO();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_ITEM_SELECTED();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_ITEM_DESELECTED();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_ITEM_ACTIVATED();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_ITEM_FOCUSED();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_ITEM_MIDDLE_CLICK();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_ITEM_RIGHT_CLICK();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_KEY_DOWN();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_INSERT_ITEM();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_COL_CLICK();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_COL_RIGHT_CLICK();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_COL_BEGIN_DRAG();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_COL_DRAGGING();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_COL_END_DRAG();
static extern (C) EventType wxEvent_EVT_COMMAND_LIST_CACHE_HINT();
static extern (C) EventType wxEvent_EVT_COMMAND_NOTEBOOK_PAGE_CHANGED();
static extern (C) EventType wxEvent_EVT_COMMAND_NOTEBOOK_PAGE_CHANGING();
static extern (C) EventType wxEvent_EVT_COMMAND_LISTBOOK_PAGE_CHANGED();
static extern (C) EventType wxEvent_EVT_COMMAND_LISTBOOK_PAGE_CHANGING();
version(__WXMSW__)
{
static extern (C) EventType wxEvent_EVT_COMMAND_TAB_SEL_CHANGED();
static extern (C) EventType wxEvent_EVT_COMMAND_TAB_SEL_CHANGING();
}
static extern (C) EventType wxEvent_EVT_GRID_CELL_LEFT_CLICK();
static extern (C) EventType wxEvent_EVT_GRID_CELL_RIGHT_CLICK();
static extern (C) EventType wxEvent_EVT_GRID_CELL_LEFT_DCLICK();
static extern (C) EventType wxEvent_EVT_GRID_CELL_RIGHT_DCLICK();
static extern (C) EventType wxEvent_EVT_GRID_LABEL_LEFT_CLICK();
static extern (C) EventType wxEvent_EVT_GRID_LABEL_RIGHT_CLICK();
static extern (C) EventType wxEvent_EVT_GRID_LABEL_LEFT_DCLICK();
static extern (C) EventType wxEvent_EVT_GRID_LABEL_RIGHT_DCLICK();
static extern (C) EventType wxEvent_EVT_GRID_ROW_SIZE();
static extern (C) EventType wxEvent_EVT_GRID_COL_SIZE();
static extern (C) EventType wxEvent_EVT_GRID_RANGE_SELECT();
static extern (C) EventType wxEvent_EVT_GRID_CELL_CHANGE();
static extern (C) EventType wxEvent_EVT_GRID_SELECT_CELL();
static extern (C) EventType wxEvent_EVT_GRID_EDITOR_SHOWN();
static extern (C) EventType wxEvent_EVT_GRID_EDITOR_HIDDEN();
static extern (C) EventType wxEvent_EVT_GRID_EDITOR_CREATED();
static extern (C) EventType wxEvent_EVT_SASH_DRAGGED();
//layoutwin
static extern (C) EventType wxEvent_EVT_QUERY_LAYOUT_INFO();
static extern (C) EventType wxEvent_EVT_CALCULATE_LAYOUT();
//! \endcond
//---------------------------------------------------------------------
alias Event wxEvent;
public class Event : wxObject
{
public static /*readonly*/ EventType wxEVT_NULL;
public static /*readonly*/ EventType wxEVT_COMMAND_BUTTON_CLICKED;
public static /*readonly*/ EventType wxEVT_COMMAND_CHECKBOX_CLICKED;
public static /*readonly*/ EventType wxEVT_COMMAND_CHOICE_SELECTED;
public static /*readonly*/ EventType wxEVT_COMMAND_LISTBOX_SELECTED;
public static /*readonly*/ EventType wxEVT_COMMAND_LISTBOX_DOUBLECLICKED;
public static /*readonly*/ EventType wxEVT_COMMAND_CHECKLISTBOX_TOGGLED;
public static /*readonly*/ EventType wxEVT_COMMAND_TEXT_UPDATED;
public static /*readonly*/ EventType wxEVT_COMMAND_TEXT_ENTER;
public static /*readonly*/ EventType wxEVT_COMMAND_TEXT_URL;
public static /*readonly*/ EventType wxEVT_COMMAND_TEXT_MAXLEN;
public static /*readonly*/ EventType wxEVT_COMMAND_MENU_SELECTED;
public static /*readonly*/ EventType wxEVT_COMMAND_TOOL_CLICKED;
public static /*readonly*/ EventType wxEVT_COMMAND_SLIDER_UPDATED;
public static /*readonly*/ EventType wxEVT_COMMAND_RADIOBOX_SELECTED;
public static /*readonly*/ EventType wxEVT_COMMAND_RADIOBUTTON_SELECTED;
public static /*readonly*/ EventType wxEVT_COMMAND_SCROLLBAR_UPDATED;
public static /*readonly*/ EventType wxEVT_COMMAND_VLBOX_SELECTED;
public static /*readonly*/ EventType wxEVT_COMMAND_COMBOBOX_SELECTED;
public static /*readonly*/ EventType wxEVT_COMMAND_TOOL_RCLICKED;
public static /*readonly*/ EventType wxEVT_COMMAND_TOOL_ENTER;
public static /*readonly*/ EventType wxEVT_COMMAND_SPINCTRL_UPDATED;
public static /*readonly*/ EventType wxEVT_SOCKET;
public static /*readonly*/ EventType wxEVT_TIMER ;
public static /*readonly*/ EventType wxEVT_LEFT_DOWN;
public static /*readonly*/ EventType wxEVT_LEFT_UP;
public static /*readonly*/ EventType wxEVT_MIDDLE_DOWN;
public static /*readonly*/ EventType wxEVT_MIDDLE_UP;
public static /*readonly*/ EventType wxEVT_RIGHT_DOWN;
public static /*readonly*/ EventType wxEVT_RIGHT_UP;
public static /*readonly*/ EventType wxEVT_MOTION;
public static /*readonly*/ EventType wxEVT_ENTER_WINDOW;
public static /*readonly*/ EventType wxEVT_LEAVE_WINDOW;
public static /*readonly*/ EventType wxEVT_LEFT_DCLICK;
public static /*readonly*/ EventType wxEVT_MIDDLE_DCLICK;
public static /*readonly*/ EventType wxEVT_RIGHT_DCLICK;
public static /*readonly*/ EventType wxEVT_SET_FOCUS;
public static /*readonly*/ EventType wxEVT_KILL_FOCUS;
public static /*readonly*/ EventType wxEVT_CHILD_FOCUS;
public static /*readonly*/ EventType wxEVT_MOUSEWHEEL;
public static /*readonly*/ EventType wxEVT_NC_LEFT_DOWN;
public static /*readonly*/ EventType wxEVT_NC_LEFT_UP;
public static /*readonly*/ EventType wxEVT_NC_MIDDLE_DOWN;
public static /*readonly*/ EventType wxEVT_NC_MIDDLE_UP;
public static /*readonly*/ EventType wxEVT_NC_RIGHT_DOWN;
public static /*readonly*/ EventType wxEVT_NC_RIGHT_UP;
public static /*readonly*/ EventType wxEVT_NC_MOTION;
public static /*readonly*/ EventType wxEVT_NC_ENTER_WINDOW;
public static /*readonly*/ EventType wxEVT_NC_LEAVE_WINDOW;
public static /*readonly*/ EventType wxEVT_NC_LEFT_DCLICK;
public static /*readonly*/ EventType wxEVT_NC_MIDDLE_DCLICK;
public static /*readonly*/ EventType wxEVT_NC_RIGHT_DCLICK;
public static /*readonly*/ EventType wxEVT_CHAR;
public static /*readonly*/ EventType wxEVT_CHAR_HOOK;
public static /*readonly*/ EventType wxEVT_NAVIGATION_KEY;
public static /*readonly*/ EventType wxEVT_KEY_DOWN;
public static /*readonly*/ EventType wxEVT_KEY_UP;
version(wxUSE_HOTKEY)
{
public static /*readonly*/ EventType wxEVT_HOTKEY;
}
public static /*readonly*/ EventType wxEVT_SET_CURSOR;
public static /*readonly*/ EventType wxEVT_SCROLL_TOP;
public static /*readonly*/ EventType wxEVT_SCROLL_BOTTOM;
public static /*readonly*/ EventType wxEVT_SCROLL_LINEUP;
public static /*readonly*/ EventType wxEVT_SCROLL_LINEDOWN;
public static /*readonly*/ EventType wxEVT_SCROLL_PAGEUP;
public static /*readonly*/ EventType wxEVT_SCROLL_PAGEDOWN;
public static /*readonly*/ EventType wxEVT_SCROLL_THUMBTRACK;
public static /*readonly*/ EventType wxEVT_SCROLL_THUMBRELEASE;
public static /*readonly*/ EventType wxEVT_SCROLL_ENDSCROLL;
public static /*readonly*/ EventType wxEVT_SCROLLWIN_TOP;
public static /*readonly*/ EventType wxEVT_SCROLLWIN_BOTTOM;
public static /*readonly*/ EventType wxEVT_SCROLLWIN_LINEUP;
public static /*readonly*/ EventType wxEVT_SCROLLWIN_LINEDOWN;
public static /*readonly*/ EventType wxEVT_SCROLLWIN_PAGEUP;
public static /*readonly*/ EventType wxEVT_SCROLLWIN_PAGEDOWN;
public static /*readonly*/ EventType wxEVT_SCROLLWIN_THUMBTRACK;
public static /*readonly*/ EventType wxEVT_SCROLLWIN_THUMBRELEASE;
public static /*readonly*/ EventType wxEVT_SIZE;
public static /*readonly*/ EventType wxEVT_MOVE;
public static /*readonly*/ EventType wxEVT_CLOSE_WINDOW;
public static /*readonly*/ EventType wxEVT_END_SESSION;
public static /*readonly*/ EventType wxEVT_QUERY_END_SESSION;
public static /*readonly*/ EventType wxEVT_ACTIVATE_APP;
public static /*readonly*/ EventType wxEVT_POWER;
public static /*readonly*/ EventType wxEVT_ACTIVATE;
public static /*readonly*/ EventType wxEVT_CREATE;
public static /*readonly*/ EventType wxEVT_DESTROY;
public static /*readonly*/ EventType wxEVT_SHOW;
public static /*readonly*/ EventType wxEVT_ICONIZE;
public static /*readonly*/ EventType wxEVT_MAXIMIZE;
public static /*readonly*/ EventType wxEVT_MOUSE_CAPTURE_CHANGED;
public static /*readonly*/ EventType wxEVT_PAINT;
public static /*readonly*/ EventType wxEVT_ERASE_BACKGROUND;
public static /*readonly*/ EventType wxEVT_NC_PAINT;
public static /*readonly*/ EventType wxEVT_PAINT_ICON;
public static /*readonly*/ EventType wxEVT_MENU_OPEN;
public static /*readonly*/ EventType wxEVT_MENU_CLOSE;
public static /*readonly*/ EventType wxEVT_MENU_HIGHLIGHT;
public static /*readonly*/ EventType wxEVT_CONTEXT_MENU;
public static /*readonly*/ EventType wxEVT_SYS_COLOUR_CHANGED;
public static /*readonly*/ EventType wxEVT_DISPLAY_CHANGED;
public static /*readonly*/ EventType wxEVT_SETTING_CHANGED;
public static /*readonly*/ EventType wxEVT_QUERY_NEW_PALETTE;
public static /*readonly*/ EventType wxEVT_PALETTE_CHANGED;
public static /*readonly*/ EventType wxEVT_JOY_BUTTON_DOWN;
public static /*readonly*/ EventType wxEVT_JOY_BUTTON_UP;
public static /*readonly*/ EventType wxEVT_JOY_MOVE;
public static /*readonly*/ EventType wxEVT_JOY_ZMOVE;
public static /*readonly*/ EventType wxEVT_DROP_FILES;
public static /*readonly*/ EventType wxEVT_DRAW_ITEM;
public static /*readonly*/ EventType wxEVT_MEASURE_ITEM;
public static /*readonly*/ EventType wxEVT_COMPARE_ITEM;
public static /*readonly*/ EventType wxEVT_INIT_DIALOG;
public static /*readonly*/ EventType wxEVT_IDLE;
public static /*readonly*/ EventType wxEVT_UPDATE_UI;
public static /*readonly*/ EventType wxEVT_SIZING;
public static /*readonly*/ EventType wxEVT_MOVING;
public static /*readonly*/ EventType wxEVT_COMMAND_LEFT_CLICK;
public static /*readonly*/ EventType wxEVT_COMMAND_LEFT_DCLICK;
public static /*readonly*/ EventType wxEVT_COMMAND_RIGHT_CLICK;
public static /*readonly*/ EventType wxEVT_COMMAND_RIGHT_DCLICK;
public static /*readonly*/ EventType wxEVT_COMMAND_SET_FOCUS;
public static /*readonly*/ EventType wxEVT_COMMAND_KILL_FOCUS;
public static /*readonly*/ EventType wxEVT_COMMAND_ENTER;
public static /*readonly*/ EventType wxEVT_HELP;
public static /*readonly*/ EventType wxEVT_DETAILED_HELP;
public static /*readonly*/ EventType wxEVT_COMMAND_TOGGLEBUTTON_CLICKED;
public static /*readonly*/ EventType wxEVT_OBJECTDELETED;
public static /*readonly*/ EventType wxEVT_CALENDAR_SEL_CHANGED;
public static /*readonly*/ EventType wxEVT_CALENDAR_DAY_CHANGED;
public static /*readonly*/ EventType wxEVT_CALENDAR_MONTH_CHANGED;
public static /*readonly*/ EventType wxEVT_CALENDAR_YEAR_CHANGED;
public static /*readonly*/ EventType wxEVT_CALENDAR_DOUBLECLICKED;
public static /*readonly*/ EventType wxEVT_CALENDAR_WEEKDAY_CLICKED;
public static /*readonly*/ EventType wxEVT_COMMAND_FIND;
public static /*readonly*/ EventType wxEVT_COMMAND_FIND_NEXT;
public static /*readonly*/ EventType wxEVT_COMMAND_FIND_REPLACE;
public static /*readonly*/ EventType wxEVT_COMMAND_FIND_REPLACE_ALL;
public static /*readonly*/ EventType wxEVT_COMMAND_FIND_CLOSE;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_BEGIN_DRAG;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_BEGIN_RDRAG;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_END_LABEL_EDIT;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_DELETE_ITEM;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_GET_INFO;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_SET_INFO;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_ITEM_EXPANDED;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_ITEM_EXPANDING;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_ITEM_COLLAPSED;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_ITEM_COLLAPSING;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_SEL_CHANGED;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_SEL_CHANGING;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_KEY_DOWN;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_ITEM_ACTIVATED;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK;
public static /*readonly*/ EventType wxEVT_COMMAND_TREE_END_DRAG;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_BEGIN_DRAG;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_BEGIN_RDRAG;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_END_LABEL_EDIT;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_DELETE_ITEM;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_GET_INFO;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_SET_INFO;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_ITEM_SELECTED;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_ITEM_DESELECTED;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_ITEM_ACTIVATED;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_ITEM_FOCUSED;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_KEY_DOWN;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_INSERT_ITEM;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_COL_CLICK;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_COL_RIGHT_CLICK;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_COL_BEGIN_DRAG;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_COL_DRAGGING;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_COL_END_DRAG;
public static /*readonly*/ EventType wxEVT_COMMAND_LIST_CACHE_HINT;
public static /*readonly*/ EventType wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED;
public static /*readonly*/ EventType wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING;
public static /*readonly*/ EventType wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED;
public static /*readonly*/ EventType wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING;
version(__WXMSW__)
{
public static /*readonly*/ EventType wxEVT_COMMAND_TAB_SEL_CHANGED;
public static /*readonly*/ EventType wxEVT_COMMAND_TAB_SEL_CHANGING;
}
public static /*readonly*/ EventType wxEVT_GRID_CELL_LEFT_CLICK;
public static /*readonly*/ EventType wxEVT_GRID_CELL_RIGHT_CLICK;
public static /*readonly*/ EventType wxEVT_GRID_CELL_LEFT_DCLICK;
public static /*readonly*/ EventType wxEVT_GRID_CELL_RIGHT_DCLICK;
public static /*readonly*/ EventType wxEVT_GRID_LABEL_LEFT_CLICK;
public static /*readonly*/ EventType wxEVT_GRID_LABEL_RIGHT_CLICK;
public static /*readonly*/ EventType wxEVT_GRID_LABEL_LEFT_DCLICK;
public static /*readonly*/ EventType wxEVT_GRID_LABEL_RIGHT_DCLICK;
public static /*readonly*/ EventType wxEVT_GRID_ROW_SIZE;
public static /*readonly*/ EventType wxEVT_GRID_COL_SIZE;
public static /*readonly*/ EventType wxEVT_GRID_RANGE_SELECT;
public static /*readonly*/ EventType wxEVT_GRID_CELL_CHANGE;
public static /*readonly*/ EventType wxEVT_GRID_SELECT_CELL;
public static /*readonly*/ EventType wxEVT_GRID_EDITOR_SHOWN;
public static /*readonly*/ EventType wxEVT_GRID_EDITOR_HIDDEN;
public static /*readonly*/ EventType wxEVT_GRID_EDITOR_CREATED;
public static /*readonly*/ EventType wxEVT_SASH_DRAGGED;
public static /*readonly*/ EventType wxEVT_QUERY_LAYOUT_INFO;
public static /*readonly*/ EventType wxEVT_CALCULATE_LAYOUT;
static this()
{
wxEVT_NULL = wxEvent_EVT_NULL();
wxEVT_COMMAND_BUTTON_CLICKED = wxEvent_EVT_COMMAND_BUTTON_CLICKED();
wxEVT_COMMAND_CHECKBOX_CLICKED = wxEvent_EVT_COMMAND_CHECKBOX_CLICKED();
wxEVT_COMMAND_CHOICE_SELECTED = wxEvent_EVT_COMMAND_CHOICE_SELECTED();
wxEVT_COMMAND_LISTBOX_SELECTED = wxEvent_EVT_COMMAND_LISTBOX_SELECTED();
wxEVT_COMMAND_LISTBOX_DOUBLECLICKED = wxEvent_EVT_COMMAND_LISTBOX_DOUBLECLICKED();
wxEVT_COMMAND_CHECKLISTBOX_TOGGLED = wxEvent_EVT_COMMAND_CHECKLISTBOX_TOGGLED();
wxEVT_COMMAND_MENU_SELECTED = wxEvent_EVT_COMMAND_MENU_SELECTED();
wxEVT_COMMAND_SLIDER_UPDATED = wxEvent_EVT_COMMAND_SLIDER_UPDATED();
wxEVT_COMMAND_RADIOBOX_SELECTED = wxEvent_EVT_COMMAND_RADIOBOX_SELECTED();
wxEVT_COMMAND_RADIOBUTTON_SELECTED = wxEvent_EVT_COMMAND_RADIOBUTTON_SELECTED();
wxEVT_COMMAND_SCROLLBAR_UPDATED = wxEvent_EVT_COMMAND_SCROLLBAR_UPDATED();
wxEVT_COMMAND_VLBOX_SELECTED = wxEvent_EVT_COMMAND_VLBOX_SELECTED();
wxEVT_COMMAND_COMBOBOX_SELECTED = wxEvent_EVT_COMMAND_COMBOBOX_SELECTED();
wxEVT_COMMAND_TOOL_RCLICKED = wxEvent_EVT_COMMAND_TOOL_RCLICKED();
wxEVT_COMMAND_TOOL_ENTER = wxEvent_EVT_COMMAND_TOOL_ENTER();
wxEVT_COMMAND_SPINCTRL_UPDATED = wxEvent_EVT_COMMAND_SPINCTRL_UPDATED();
wxEVT_COMMAND_TOOL_CLICKED = wxEVT_COMMAND_MENU_SELECTED;
wxEVT_COMMAND_TEXT_UPDATED = wxEvent_EVT_COMMAND_TEXT_UPDATED();
wxEVT_COMMAND_TEXT_ENTER = wxEvent_EVT_COMMAND_TEXT_ENTER();
wxEVT_COMMAND_TEXT_URL = wxEvent_EVT_COMMAND_TEXT_URL();
wxEVT_COMMAND_TEXT_MAXLEN = wxEvent_EVT_COMMAND_TEXT_MAXLEN();
wxEVT_SOCKET = wxEvent_EVT_SOCKET();
wxEVT_TIMER = wxEvent_EVT_TIMER ();
wxEVT_LEFT_DOWN = wxEvent_EVT_LEFT_DOWN();
wxEVT_LEFT_UP = wxEvent_EVT_LEFT_UP();
wxEVT_MIDDLE_DOWN = wxEvent_EVT_MIDDLE_DOWN();
wxEVT_MIDDLE_UP = wxEvent_EVT_MIDDLE_UP();
wxEVT_RIGHT_DOWN = wxEvent_EVT_RIGHT_DOWN();
wxEVT_RIGHT_UP = wxEvent_EVT_RIGHT_UP();
wxEVT_MOTION = wxEvent_EVT_MOTION();
wxEVT_ENTER_WINDOW = wxEvent_EVT_ENTER_WINDOW();
wxEVT_LEAVE_WINDOW = wxEvent_EVT_LEAVE_WINDOW();
wxEVT_LEFT_DCLICK = wxEvent_EVT_LEFT_DCLICK();
wxEVT_MIDDLE_DCLICK = wxEvent_EVT_MIDDLE_DCLICK();
wxEVT_RIGHT_DCLICK = wxEvent_EVT_RIGHT_DCLICK();
wxEVT_SET_FOCUS = wxEvent_EVT_SET_FOCUS();
wxEVT_KILL_FOCUS = wxEvent_EVT_KILL_FOCUS();
wxEVT_CHILD_FOCUS = wxEvent_EVT_CHILD_FOCUS();
wxEVT_MOUSEWHEEL = wxEvent_EVT_MOUSEWHEEL();
wxEVT_NC_LEFT_DOWN = wxEvent_EVT_NC_LEFT_DOWN();
wxEVT_NC_LEFT_UP = wxEvent_EVT_NC_LEFT_UP();
wxEVT_NC_MIDDLE_DOWN = wxEvent_EVT_NC_MIDDLE_DOWN();
wxEVT_NC_MIDDLE_UP = wxEvent_EVT_NC_MIDDLE_UP();
wxEVT_NC_RIGHT_DOWN = wxEvent_EVT_NC_RIGHT_DOWN();
wxEVT_NC_RIGHT_UP = wxEvent_EVT_NC_RIGHT_UP();
wxEVT_NC_MOTION = wxEvent_EVT_NC_MOTION();
wxEVT_NC_ENTER_WINDOW = wxEvent_EVT_NC_ENTER_WINDOW();
wxEVT_NC_LEAVE_WINDOW = wxEvent_EVT_NC_LEAVE_WINDOW();
wxEVT_NC_LEFT_DCLICK = wxEvent_EVT_NC_LEFT_DCLICK();
wxEVT_NC_MIDDLE_DCLICK = wxEvent_EVT_NC_MIDDLE_DCLICK();
wxEVT_NC_RIGHT_DCLICK = wxEvent_EVT_NC_RIGHT_DCLICK();
wxEVT_CHAR = wxEvent_EVT_CHAR();
wxEVT_CHAR_HOOK = wxEvent_EVT_CHAR_HOOK();
wxEVT_NAVIGATION_KEY = wxEvent_EVT_NAVIGATION_KEY();
wxEVT_KEY_DOWN = wxEvent_EVT_KEY_DOWN();
wxEVT_KEY_UP = wxEvent_EVT_KEY_UP();
version(wxUSE_HOTKEY)
{
wxEVT_HOTKEY = wxEvent_HOTKEY();
}
wxEVT_SET_CURSOR = wxEvent_EVT_SET_CURSOR();
wxEVT_SCROLL_TOP = wxEvent_EVT_SCROLL_TOP();
wxEVT_SCROLL_BOTTOM = wxEvent_EVT_SCROLL_BOTTOM();
wxEVT_SCROLL_LINEUP = wxEvent_EVT_SCROLL_LINEUP();
wxEVT_SCROLL_LINEDOWN = wxEvent_EVT_SCROLL_LINEDOWN();
wxEVT_SCROLL_PAGEUP = wxEvent_EVT_SCROLL_PAGEUP();
wxEVT_SCROLL_PAGEDOWN = wxEvent_EVT_SCROLL_PAGEDOWN();
wxEVT_SCROLL_THUMBTRACK = wxEvent_EVT_SCROLL_THUMBTRACK();
wxEVT_SCROLL_THUMBRELEASE = wxEvent_EVT_SCROLL_THUMBRELEASE();
wxEVT_SCROLL_ENDSCROLL = wxEvent_EVT_SCROLL_ENDSCROLL();
wxEVT_SCROLLWIN_TOP = wxEvent_EVT_SCROLLWIN_TOP();
wxEVT_SCROLLWIN_BOTTOM = wxEvent_EVT_SCROLLWIN_BOTTOM();
wxEVT_SCROLLWIN_LINEUP = wxEvent_EVT_SCROLLWIN_LINEUP();
wxEVT_SCROLLWIN_LINEDOWN = wxEvent_EVT_SCROLLWIN_LINEDOWN();
wxEVT_SCROLLWIN_PAGEUP = wxEvent_EVT_SCROLLWIN_PAGEUP();
wxEVT_SCROLLWIN_PAGEDOWN = wxEvent_EVT_SCROLLWIN_PAGEDOWN();
wxEVT_SCROLLWIN_THUMBTRACK = wxEvent_EVT_SCROLLWIN_THUMBTRACK();
wxEVT_SCROLLWIN_THUMBRELEASE = wxEvent_EVT_SCROLLWIN_THUMBRELEASE();
wxEVT_SIZE = wxEvent_EVT_SIZE();
wxEVT_SIZING = wxEvent_EVT_SIZING();
wxEVT_MOVE = wxEvent_EVT_MOVE();
wxEVT_MOVING = wxEvent_EVT_MOVING();
wxEVT_CLOSE_WINDOW = wxEvent_EVT_CLOSE_WINDOW();
wxEVT_END_SESSION = wxEvent_EVT_END_SESSION();
wxEVT_QUERY_END_SESSION = wxEvent_EVT_QUERY_END_SESSION();
wxEVT_ACTIVATE_APP = wxEvent_EVT_ACTIVATE_APP();
wxEVT_POWER = wxEvent_EVT_POWER();
wxEVT_ACTIVATE = wxEvent_EVT_ACTIVATE();
wxEVT_CREATE = wxEvent_EVT_CREATE();
wxEVT_DESTROY = wxEvent_EVT_DESTROY();
wxEVT_SHOW = wxEvent_EVT_SHOW();
wxEVT_ICONIZE = wxEvent_EVT_ICONIZE();
wxEVT_MAXIMIZE = wxEvent_EVT_MAXIMIZE();
wxEVT_MOUSE_CAPTURE_CHANGED = wxEvent_EVT_MOUSE_CAPTURE_CHANGED();
wxEVT_PAINT = wxEvent_EVT_PAINT();
wxEVT_ERASE_BACKGROUND = wxEvent_EVT_ERASE_BACKGROUND();
wxEVT_NC_PAINT = wxEvent_EVT_NC_PAINT();
wxEVT_PAINT_ICON = wxEvent_EVT_PAINT_ICON();
wxEVT_MENU_OPEN = wxEvent_EVT_MENU_OPEN();
wxEVT_MENU_CLOSE = wxEvent_EVT_MENU_CLOSE();
wxEVT_MENU_HIGHLIGHT = wxEvent_EVT_MENU_HIGHLIGHT();
wxEVT_CONTEXT_MENU = wxEvent_EVT_CONTEXT_MENU();
wxEVT_SYS_COLOUR_CHANGED = wxEvent_EVT_SYS_COLOUR_CHANGED();
wxEVT_DISPLAY_CHANGED = wxEvent_EVT_DISPLAY_CHANGED();
wxEVT_SETTING_CHANGED = wxEvent_EVT_SETTING_CHANGED();
wxEVT_QUERY_NEW_PALETTE = wxEvent_EVT_QUERY_NEW_PALETTE();
wxEVT_PALETTE_CHANGED = wxEvent_EVT_PALETTE_CHANGED();
wxEVT_JOY_BUTTON_DOWN = wxEvent_EVT_JOY_BUTTON_DOWN();
wxEVT_JOY_BUTTON_UP = wxEvent_EVT_JOY_BUTTON_UP();
wxEVT_JOY_MOVE = wxEvent_EVT_JOY_MOVE();
wxEVT_JOY_ZMOVE = wxEvent_EVT_JOY_ZMOVE();
wxEVT_DROP_FILES = wxEvent_EVT_DROP_FILES();
wxEVT_DRAW_ITEM = wxEvent_EVT_DRAW_ITEM();
wxEVT_MEASURE_ITEM = wxEvent_EVT_MEASURE_ITEM();
wxEVT_COMPARE_ITEM = wxEvent_EVT_COMPARE_ITEM();
wxEVT_INIT_DIALOG = wxEvent_EVT_INIT_DIALOG();
wxEVT_IDLE = wxEvent_EVT_IDLE();
wxEVT_UPDATE_UI = wxEvent_EVT_UPDATE_UI();
wxEVT_COMMAND_LEFT_CLICK = wxEvent_EVT_COMMAND_LEFT_CLICK();
wxEVT_COMMAND_LEFT_DCLICK = wxEvent_EVT_COMMAND_LEFT_DCLICK();
wxEVT_COMMAND_RIGHT_CLICK = wxEvent_EVT_COMMAND_RIGHT_CLICK();
wxEVT_COMMAND_RIGHT_DCLICK = wxEvent_EVT_COMMAND_RIGHT_DCLICK();
wxEVT_COMMAND_SET_FOCUS = wxEvent_EVT_COMMAND_SET_FOCUS();
wxEVT_COMMAND_KILL_FOCUS = wxEvent_EVT_COMMAND_KILL_FOCUS();
wxEVT_COMMAND_ENTER = wxEvent_EVT_COMMAND_ENTER();
wxEVT_HELP = wxEvent_EVT_HELP();
wxEVT_DETAILED_HELP = wxEvent_EVT_DETAILED_HELP();
wxEVT_COMMAND_TOGGLEBUTTON_CLICKED = wxEvent_EVT_COMMAND_TOGGLEBUTTON_CLICKED();
wxEVT_OBJECTDELETED = wxEvent_EVT_OBJECTDELETED();
}
//---------------------------------------------------------------------
alias static Event function(IntPtr wxobj) newfunc;
protected static newfunc[EventType] funcmap;
//---------------------------------------------------------------------
private static Event New(IntPtr obj);
public static void AddEventType(EventType evt, newfunc func);
public this(IntPtr wxobj) ;
public static Event CreateFrom(IntPtr wxEvent);
public EventType eventType() ;
public int ID();
public void Skip();
public bool Skipped() ;
public int Timestamp();
public wxObject EventObject();
public void EventObject(wxObject obj);
public IntPtr EventIntPtr() ;
public void EventIntPtr(IntPtr ptr);
}
|
D
|
// Copyright Steve Teale 2011.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// Written in the D programming language
module teardrop;
import mainwin;
import constants;
import acomp;
import common;
import types;
import controlset;
import lineset;
import mol;
import std.stdio;
import std.conv;
import gtk.Widget;
import gtk.Label;
import gtk.Button;
import gtk.ComboBoxText;
import gtk.SpinButton;
import gtk.CheckButton;
import gdk.RGBA;
import cairo.Context;
import cairo.Matrix;
import cairo.Surface;
class Teardrop: LineSet
{
static int nextOid = 0;
static immutable double m = 0.55191502449/2;
static immutable Coord[13] crd = [ Coord(0.5, 0.4), Coord(0.5, 0.4+m), Coord(m, 0.9), Coord(0, 0.9),
Coord(-m, 0.9), Coord(-0.5, 0.4+m), Coord(-0.5, 0.4),
Coord(-0.5, 0.1), Coord(-0.05, -0.2), Coord(0, -0.8),
Coord(0.05, -0.2), Coord(0.5, 0.1), Coord(0.5, 0.4)];
double unit;
override void syncControls()
{
cSet.setLineParams(lineWidth);
cSet.toggling(false);
if (outline)
cSet.setToggle(Purpose.OUTLINE, true);
cSet.setLabel(Purpose.LINEWIDTH, formatLT(lineWidth));
cSet.toggling(true);
cSet.setComboIndex(Purpose.XFORMCB, xform);
cSet.setComboIndex(Purpose.FILLOPTIONS, 0);
cSet.setHostName(name);
}
this(Teardrop other)
{
this(other.aw, other.parent);
hOff = other.hOff;
vOff = other.vOff;
baseColor = other.baseColor.copy();
altColor = other.altColor.copy();
center = other.center;
lineWidth = other.lineWidth;
unit = other.unit;
tf = other.tf;
fill = other.fill;
outline = other.outline;
fillFromPattern = other.fillFromPattern;
fillUid = other.fillUid;
updateFillUI();
constructBase();
syncControls();
}
this(AppWindow w, ACBase parent)
{
mixin(initString!Teardrop());
super(w, parent, sname, AC_TEARDROP, ACGroups.SHAPES, ahdg);
closed = true;
hOff = vOff = 0;
altColor = new RGBA(1,0,0,1);
center = Coord(0.5*width, 0.5*height);
lineWidth = 0.5;
fill = false;
unit = width > height? height*0.5: width*0.5;
constructBase();
xform = 0;
tm = new Matrix(&tmData);
setupControls();
outline = true;
positionControls(true);
}
override void extendControls()
{
int vp = cSet.cy;
Label l = new Label("Size");
cSet.add(l, ICoord(255, vp-24), Purpose.LABEL);
new MoreLess(cSet, 0, ICoord(295, vp-24), true);
new InchTool(cSet, 0, ICoord(0, vp), true);
ComboBoxText cbb = new ComboBoxText(false);
cbb.setTooltipText("Select transformation to apply");
cbb.setSizeRequest(100, -1);
cbb.appendText("Scale");
cbb.appendText("Stretch-H");
cbb.appendText("Stretch-V");
cbb.appendText("Skew-H");
cbb.appendText("Skew-V");
cbb.appendText("Rotate");
cbb.appendText("Flip-H");
cbb.appendText("Flip-V");
cbb.setActive(0);
cSet.add(cbb, ICoord(190, vp), Purpose.XFORMCB);
new MoreLess(cSet, 1, ICoord(295, vp), true);
cSet.cy = vp+40;
}
override bool notifyHandler(Widget w, Purpose p) { return false; }
override bool undoHandler(CheckPoint cp)
{
switch (cp.type)
{
case OP_SIZE:
unit = cp.dVal;
constructBase();
break;
default:
return false;
}
lastOp = OP_UNDEF;
return true;
}
override void afterDeserialize()
{
constructBase();
}
override void preResize(int oldW, int oldH)
{
double hr = cast(double) width/oldW;
double vr = cast(double) height/oldH;
unit = width>height? 0.6666*height: 0.6666*width;
hOff *= hr;
vOff *= vr;
}
void constructBase()
{
oPath = crd.dup;
for (size_t i = 0; i < oPath.length; i++)
{
oPath[i].x *= unit;
oPath[i].y *= unit;
oPath[i].x += center.x;
oPath[i].y += center.y;
}
}
override void onCSMoreLess(int instance, bool more, bool quickly)
{
focusLayout();
switch (instance)
{
case 0:
double result = unit;
if (!molG!double(more, quickly, result, 0.01, 0.1, 1000))
return;
lastOp = pushC!double(this, unit, OP_SIZE);
unit = result;
constructBase();
break;
case 1:
modifyTransform(xform, more, quickly);
break;
default:
return;
}
dirty = true;
aw.dirty = true;
reDraw();
}
override void render(Context c)
{
c.setLineWidth(0);
c.setSourceRgb(baseColor.red, baseColor.green, baseColor.blue);
c.translate(hOff+center.x, vOff+center.y);
if (compoundTransform())
c.transform(tm);
c.translate(-center.x, -center.y);
c.moveTo(oPath[0].x, oPath[0].y);
c.curveTo(oPath[1].x, oPath[1].y, oPath[2].x, oPath[2].y, oPath[3].x, oPath[3].y);
c.curveTo(oPath[4].x, oPath[4].y, oPath[5].x, oPath[5].y, oPath[6].x, oPath[6].y);
c.curveTo(oPath[7].x, oPath[7].y, oPath[8].x, oPath[8].y, oPath[9].x, oPath[9].y);
c.curveTo(oPath[10].x, oPath[10].y, oPath[11].x, oPath[11].y, oPath[12].x, oPath[12].y);
c.closePath();
strokeAndFill(c, lineWidth, outline, fill);
}
}
|
D
|
/Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Intermediates.noindex/NYTSample.build/Debug-iphonesimulator/NYTSampleTests.build/Objects-normal/x86_64/Result.o : /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/JSON.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/MediaMetadata.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Bindable.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Mock/MockArticle.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/ArticleResponse.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/MediaModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/ArticleModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/ViewModel/ArticlesTableViewModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/ViewModel/ArticleCellViewModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Util/BindableTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/NYTSampleTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Model/ArticleResponseTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/ViewModel/ArticlesTableVIewModelTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Util/AlertTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Result.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Constant.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Service/APIClient.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Alert.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotesc /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Modules/PKHUD.swiftmodule/x86_64.swiftmodule /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/NYTSample.swiftmodule/x86_64.swiftmodule /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/Alamofire.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/XCTest.swiftmodule /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Headers/PKHUD.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImage+GIF.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Headers/PKHUD-umbrella.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImage-umbrella.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-umbrella.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIButton+WebCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImageView+WebCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImageView+HighlightedWebCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDImageCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/NSData+ImageContentType.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageOperation.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIView+WebCacheOperation.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageDownloaderOperation.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageDownloader.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageDecoder.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageManager.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImagePrefetcher.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImage+MultiFormat.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageCompat.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Headers/PKHUD-Swift.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-Swift.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Modules/module.modulemap /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Modules/module.modulemap /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/Library/Frameworks/XCTest.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/Library/Frameworks/XCTest.framework/Headers/XCTest.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Intermediates.noindex/NYTSample.build/Debug-iphonesimulator/NYTSampleTests.build/Objects-normal/x86_64/Result~partial.swiftmodule : /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/JSON.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/MediaMetadata.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Bindable.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Mock/MockArticle.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/ArticleResponse.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/MediaModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/ArticleModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/ViewModel/ArticlesTableViewModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/ViewModel/ArticleCellViewModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Util/BindableTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/NYTSampleTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Model/ArticleResponseTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/ViewModel/ArticlesTableVIewModelTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Util/AlertTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Result.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Constant.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Service/APIClient.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Alert.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotesc /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Modules/PKHUD.swiftmodule/x86_64.swiftmodule /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/NYTSample.swiftmodule/x86_64.swiftmodule /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/Alamofire.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/XCTest.swiftmodule /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Headers/PKHUD.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImage+GIF.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Headers/PKHUD-umbrella.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImage-umbrella.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-umbrella.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIButton+WebCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImageView+WebCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImageView+HighlightedWebCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDImageCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/NSData+ImageContentType.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageOperation.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIView+WebCacheOperation.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageDownloaderOperation.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageDownloader.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageDecoder.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageManager.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImagePrefetcher.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImage+MultiFormat.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageCompat.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Headers/PKHUD-Swift.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-Swift.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Modules/module.modulemap /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Modules/module.modulemap /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/Library/Frameworks/XCTest.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/Library/Frameworks/XCTest.framework/Headers/XCTest.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Intermediates.noindex/NYTSample.build/Debug-iphonesimulator/NYTSampleTests.build/Objects-normal/x86_64/Result~partial.swiftdoc : /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/JSON.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/MediaMetadata.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Bindable.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Mock/MockArticle.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/ArticleResponse.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/MediaModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Model/ArticleModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/ViewModel/ArticlesTableViewModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/ViewModel/ArticleCellViewModel.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Util/BindableTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/NYTSampleTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Model/ArticleResponseTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/ViewModel/ArticlesTableVIewModelTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSampleTests/Util/AlertTests.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Result.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Constant.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Service/APIClient.swift /Users/hauyadav/Learn/nysample/NYTSample/NYTSample/Util/Alert.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotesc /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Modules/PKHUD.swiftmodule/x86_64.swiftmodule /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/NYTSample.swiftmodule/x86_64.swiftmodule /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/Alamofire.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/XCTest.swiftmodule /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Headers/PKHUD.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImage+GIF.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Headers/PKHUD-umbrella.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImage-umbrella.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-umbrella.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIButton+WebCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImageView+WebCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImageView+HighlightedWebCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDImageCache.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/NSData+ImageContentType.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageOperation.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIView+WebCacheOperation.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageDownloaderOperation.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageDownloader.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageDecoder.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageManager.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImagePrefetcher.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/UIImage+MultiFormat.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Headers/SDWebImageCompat.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Headers/PKHUD-Swift.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Headers/Alamofire-Swift.h /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/PKHUD/PKHUD.framework/Modules/module.modulemap /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/SDWebImage/SDWebImage.framework/Modules/module.modulemap /Users/hauyadav/Learn/nysample/NYTSample/Build/Build/Products/Debug-iphonesimulator/Alamofire/Alamofire.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/Library/Frameworks/XCTest.framework/Modules/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/OpenGLES.framework/Headers/OpenGLES.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/CoreImage.framework/Headers/CoreImage.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/QuartzCore.framework/Headers/QuartzCore.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/Metal.framework/Headers/Metal.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/Library/Frameworks/XCTest.framework/Headers/XCTest.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
|
D
|
release or vent
release from a leash
turn loose or free from restraint
|
D
|
module android.java.javax.xml.transform.TransformerFactory;
public import android.java.javax.xml.transform.TransformerFactory_d_interface;
import arsd.jni : ImportExportImpl;
mixin ImportExportImpl!TransformerFactory;
import import4 = android.java.javax.xml.transform.Templates;
import import2 = android.java.javax.xml.transform.Transformer;
import import0 = android.java.javax.xml.transform.TransformerFactory;
import import7 = android.java.java.lang.Class;
|
D
|
module d2d.game.world.map.mapcontroller;
import d2d.game.world.map.map;
/*
A mapcotroller can (mut dosnt have to) be set for a map
Mapcontrollers should be derived from Base as a map will try to set it as its child
They exsist to handle common tasks, interface with the map above them etc.
*/
interface Mapcontroller
{
void onMapload();
void onMapUnload();
void setMap(Map m);
}
|
D
|
instance VLK_6020_HARUM(Npc_Default)
{
name[0] = "Elvais";
guild = GIL_OUT;
id = 6020;
voice = 1;
flags = 0;
npcType = npctype_main;
B_SetAttributesToChapter(self,5);
aivar[AIV_PlayerHasPickedMyPocket] = TRUE;
fight_tactic = FAI_HUMAN_MASTER;
B_CreateAmbientInv(self);
B_SetNpcVisual(self,MALE,"Hum_Head_FatBald",Face_N_Raven,BodyTex_N,ItAr_Wizard_NPC);
Mdl_SetModelFatness(self,0);
Mdl_ApplyOverlayMds(self,"Humans_Militia.mds");
B_GiveNpcTalents(self);
B_SetFightSkills(self,80);
aivar[AIV_MagicUser] = MAGIC_ALWAYS;
daily_routine = rtn_start_6020;
};
func void rtn_start_6020()
{
TA_Read_Bookstand(8,0,21,0,"SV_HUMAN_20");
TA_Read_Bookstand(21,0,8,0,"SV_HUMAN_20");
};
|
D
|
import dshell;
int main()
{
version (Windows) if (Vars.MODEL == "32") // Avoid optlink
return DISABLED;
Vars.set(`SRC`, `$EXTRA_FILES/dll`);
Vars.set(`EXE_NAME`, `$OUTPUT_BASE/testdll$EXE`);
Vars.set(`DLL`, `$OUTPUT_BASE/mydll$SOEXT`);
version (Windows)
{
enum dllExtra = `$SRC/dllmain.d`;
enum mainExtra = `$OUTPUT_BASE/mydll$LIBEXT`;
}
else
{
// Segfaults without PIC - using hardcoded -fPIC and not $PIC_FLAG as
// the latter can be set to an empty string.
enum dllExtra = `-fPIC`;
enum mainExtra = `-fPIC -L-L$OUTPUT_BASE -L$DLL`;
}
run(`$DMD -m$MODEL -shared -od=$OUTPUT_BASE -of=$DLL $SRC/mydll.d ` ~ dllExtra);
run(`$DMD -m$MODEL -I$SRC -od=$OUTPUT_BASE -of=$EXE_NAME $SRC/testdll.d ` ~ mainExtra);
run(`$EXE_NAME`, stdout, stderr, [`LD_LIBRARY_PATH`: Vars.OUTPUT_BASE]);
return 0;
}
|
D
|
/home/owen/github/cryptopals/cryptopals/set1/detect_single_byte_XOR/target/debug/build/byteorder-3c046f6b37473af9/build_script_build-3c046f6b37473af9: /home/owen/.cargo/registry/src/github.com-1ecc6299db9ec823/byteorder-1.3.4/build.rs
/home/owen/github/cryptopals/cryptopals/set1/detect_single_byte_XOR/target/debug/build/byteorder-3c046f6b37473af9/build_script_build-3c046f6b37473af9.d: /home/owen/.cargo/registry/src/github.com-1ecc6299db9ec823/byteorder-1.3.4/build.rs
/home/owen/.cargo/registry/src/github.com-1ecc6299db9ec823/byteorder-1.3.4/build.rs:
|
D
|
module protection2;
import std.stdio;
class MyClass {
private void sayHello() {
writeln("Hello");
}
}
struct MyStruct {
void sayHello() {
MyClass mc = new MyClass;
mc.sayHello();
}
}
|
D
|
module foundation.array;
version(D_ObjectiveC) {
import foundation.object;
import core.attribute : selector;
extern (Objective-C):
extern class NSArray : NSObject {
public:
@property int count () @selector("count");
}
}
|
D
|
instance BDT_10009_Addon_Bandit(Npc_Default)
{
name[0] = NAME_Bandit;
guild = GIL_BDT;
id = 10009;
voice = 13;
flags = 0;
npcType = NPCTYPE_BL_AMBIENT;
B_SetAttributesToChapter(self,2);
fight_tactic = FAI_HUMAN_STRONG;
EquipItem(self,ItMw_Nagelknueppel);
B_CreateAmbientInv(self);
B_SetNpcVisual(self,MALE,"Hum_Head_Bald",Face_P_Weak_Cutter,BodyTex_P,ITAR_Prisoner);
Mdl_SetModelFatness(self,-1);
Mdl_ApplyOverlayMds(self,"Humans_Tired.mds");
B_GiveNpcTalents(self);
B_SetFightSkills(self,30);
daily_routine = Rtn_Start_10009;
};
func void Rtn_Start_10009()
{
TA_Smalltalk(8,0,10,0,"BL_UP_RING_04");
TA_Smalltalk(10,0,8,0,"BL_UP_RING_04");
};
|
D
|
/Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/SQLite.build/Database/SQLiteStorage.swift.o : /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+0.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteData.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Utilities/Deprecated.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteStorage.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+CreateTable.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+DropTable.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+AlterTable.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteDataConvertible.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TableName.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TypeName.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteDataType.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+Compare.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteDatabase.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Update.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Delete.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+With.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+Literal.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Join.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Column.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+IndexedColumn.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteColumn.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteConnection.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Direction.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ColumnDefinition.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ConflictResolution.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+DropTableBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+AlterTableBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+UpdateBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+CreateBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+DeleteBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+SelectBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+InsertBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteDataDecoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteRowDecoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteQueryExpressionEncoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteQueryEncoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuerySerializer.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Utilities/SQLiteError.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+UnaryOperator.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+BinaryOperator.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+SetValues.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Utilities/Exports.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Select.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteStatement.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TableConstraint.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ColumnConstraint.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Insert.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ForeignKey.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TableOrSubquery.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.apinotesc /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/NIO.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Async.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Service.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Core.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Debugging.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/NIOConcurrencyHelpers.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Bits.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/NIOFoundationCompat.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/DatabaseKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/cpp_magic.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIODarwin/include/c_nio_darwin.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/c-atomics.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOLinux/include/c_nio_linux.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio-zlib-support.git--1071467962839356487/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOSHA1.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOOpenSSL.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOZlib.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIODarwin.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOHTTPParser.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOAtomics.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOLinux.build/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes
/Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/SQLite.build/SQLiteStorage~partial.swiftmodule : /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+0.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteData.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Utilities/Deprecated.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteStorage.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+CreateTable.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+DropTable.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+AlterTable.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteDataConvertible.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TableName.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TypeName.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteDataType.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+Compare.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteDatabase.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Update.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Delete.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+With.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+Literal.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Join.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Column.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+IndexedColumn.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteColumn.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteConnection.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Direction.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ColumnDefinition.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ConflictResolution.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+DropTableBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+AlterTableBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+UpdateBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+CreateBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+DeleteBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+SelectBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+InsertBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteDataDecoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteRowDecoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteQueryExpressionEncoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteQueryEncoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuerySerializer.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Utilities/SQLiteError.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+UnaryOperator.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+BinaryOperator.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+SetValues.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Utilities/Exports.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Select.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteStatement.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TableConstraint.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ColumnConstraint.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Insert.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ForeignKey.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TableOrSubquery.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.apinotesc /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/NIO.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Async.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Service.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Core.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Debugging.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/NIOConcurrencyHelpers.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Bits.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/NIOFoundationCompat.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/DatabaseKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/cpp_magic.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIODarwin/include/c_nio_darwin.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/c-atomics.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOLinux/include/c_nio_linux.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio-zlib-support.git--1071467962839356487/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOSHA1.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOOpenSSL.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOZlib.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIODarwin.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOHTTPParser.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOAtomics.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOLinux.build/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes
/Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/SQLite.build/SQLiteStorage~partial.swiftdoc : /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+0.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteData.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Utilities/Deprecated.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteStorage.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+CreateTable.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+DropTable.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+AlterTable.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteDataConvertible.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TableName.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TypeName.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteDataType.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+Compare.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteDatabase.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Update.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Delete.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+With.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+Literal.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Join.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Column.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+IndexedColumn.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Row/SQLiteColumn.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteConnection.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Direction.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ColumnDefinition.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ConflictResolution.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+DropTableBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+AlterTableBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+UpdateBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+CreateBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+DeleteBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+SelectBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+InsertBuilder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteDataDecoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteRowDecoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteQueryExpressionEncoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Codable/SQLiteQueryEncoder.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuerySerializer.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Utilities/SQLiteError.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+UnaryOperator.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Expression+BinaryOperator.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+SetValues.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Utilities/Exports.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Select.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Database/SQLiteStatement.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TableConstraint.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ColumnConstraint.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+Insert.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+ForeignKey.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery.swift /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/sqlite.git--8232814251736334455/Sources/SQLite/Query/SQLiteQuery+TableOrSubquery.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.apinotesc /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/NIO.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Async.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Service.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Core.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Debugging.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/NIOConcurrencyHelpers.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/Bits.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/NIOFoundationCompat.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/DatabaseKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/cpp_magic.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIODarwin/include/c_nio_darwin.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/c-atomics.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOLinux/include/c_nio_linux.h /Users/user/Documents/RiseTimeAssets/server/.build/checkouts/swift-nio-zlib-support.git--1071467962839356487/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOSHA1.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOOpenSSL.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOZlib.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIODarwin.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOHTTPParser.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOAtomics.build/module.modulemap /Users/user/Documents/RiseTimeAssets/server/.build/x86_64-apple-macosx10.10/debug/CNIOLinux.build/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes
|
D
|
module cf.spew.implementation.windowing.misc;
import cf.spew.ui.display;
import cf.spew.ui.context.defs;
import cf.spew.ui.window.defs;
import cf.spew.bindings.symbolloader;
version(Windows) {
public import winapi = core.sys.windows.windows;
enum WindowDWStyles : winapi.DWORD {
Dialog = winapi.WS_OVERLAPPED | winapi.WS_CAPTION | winapi.WS_SYSMENU | winapi.WS_THICKFRAME | winapi.WS_MINIMIZEBOX | winapi.WS_MAXIMIZEBOX,
DialogEx = winapi.WS_EX_ACCEPTFILES | winapi.WS_EX_APPWINDOW,
Borderless = winapi.WS_OVERLAPPED | winapi.WS_CAPTION | winapi.WS_SYSMENU | winapi.WS_BORDER | winapi.WS_MINIMIZEBOX,
BorderlessEx = winapi.WS_EX_ACCEPTFILES | winapi.WS_EX_APPWINDOW,
Popup = winapi.WS_POPUPWINDOW | winapi.WS_CAPTION | winapi.WS_SYSMENU | winapi.WS_BORDER | winapi.WS_MINIMIZEBOX,
PopupEx = winapi.WS_EX_ACCEPTFILES | winapi.WS_EX_APPWINDOW | winapi.WS_EX_TOPMOST,
Fullscreen = winapi.WS_POPUP | winapi.WS_CLIPCHILDREN | winapi.WS_CLIPSIBLINGS,
FullscreenEx = winapi.WS_EX_APPWINDOW | winapi.WS_EX_TOPMOST,
NoDecorations = winapi.WS_POPUP,
NoDecorationsEx = winapi.WS_EX_TOPMOST | winapi.WS_EX_TRANSPARENT
}
static wstring ClassNameW = __MODULE__ ~ ":Class"w;
struct PHYSICAL_MONITOR {
winapi.HANDLE hPhysicalMonitor;
winapi.WCHAR[PHYSICAL_MONITOR_DESCRIPTION_SIZE] szPhysicalMonitorDescription;
}
enum {
PHYSICAL_MONITOR_DESCRIPTION_SIZE = 128,
MC_CAPS_BRIGHTNESS = 0x00000002,
NOTIFYICON_VERSION_4 = 4,
NIF_SHOWTIP = 0x00000080,
NIF_REALTIME = 0x00000040,
}
extern(Windows) {
// dxva2
winapi.BOOL function(winapi.HANDLE hMonitor, winapi.LPDWORD pdwMonitorCapabilities, winapi.LPDWORD pdwSupportedColorTemperatures) GetMonitorCapabilities;
winapi.BOOL function(winapi.HANDLE hMonitor, winapi.LPDWORD pdwMinimumBrightness, winapi.LPDWORD pdwCurrentBrightness, winapi.LPDWORD pdwMaximumBrightness) GetMonitorBrightness;
winapi.BOOL function(winapi.HMONITOR hMonitor, winapi.DWORD dwPhysicalMonitorArraySize, PHYSICAL_MONITOR* pPhysicalMonitorArray) GetPhysicalMonitorsFromHMONITOR;
}
SharedLib dxva2;
static this() {
import cf.spew.implementation.windowing.misc;
dxva2.load(["dxva2.dll"]);
if (dxva2.isLoaded) {
GetMonitorCapabilities = cast(typeof(GetMonitorCapabilities))dxva2.loadSymbol("GetMonitorCapabilities", false);
GetMonitorBrightness = cast(typeof(GetMonitorBrightness))dxva2.loadSymbol("GetMonitorCapabilities", false);
GetPhysicalMonitorsFromHMONITOR = cast(typeof(GetPhysicalMonitorsFromHMONITOR))dxva2.loadSymbol("GetMonitorCapabilities", false);
}
}
static ~this() {
if (dxva2.isLoaded) {
dxva2.unload();
}
}
//
import cf.spew.ui.rendering : vec2;
import std.experimental.graphic.image : ImageStorage;
import std.experimental.graphic.color : RGB8, RGBA8;
import std.experimental.containers.list;
import std.experimental.containers.map;
import std.experimental.allocator : IAllocator, ISharedAllocator, processAllocator, theAllocator, dispose, make, makeArray, expandArray, shrinkArray;
import std.experimental.memory.managed;
ImageStorage!RGB8 screenshotImpl_WinAPI(IAllocator alloc, winapi.HDC hFrom, uint width, uint height) {
winapi.HDC hMemoryDC = winapi.CreateCompatibleDC(hFrom);
winapi.HBITMAP hBitmap = winapi.CreateCompatibleBitmap(hFrom, width, height);
winapi.HBITMAP hOldBitmap = winapi.SelectObject(hMemoryDC, hBitmap);
winapi.BitBlt(hMemoryDC, 0, 0, width, height, hFrom, 0, 0, winapi.SRCCOPY);
auto storage = bitmapToImage_WinAPI(hBitmap, hMemoryDC, vec2!size_t(width, height), alloc);
hBitmap = winapi.SelectObject(hMemoryDC, hOldBitmap);
winapi.DeleteDC(hMemoryDC);
return storage;
}
ImageStorage!RGB8 bitmapToImage_WinAPI(winapi.HBITMAP hBitmap, winapi.HDC hMemoryDC, vec2!size_t size_, IAllocator alloc) {
import std.experimental.graphic.image.storage.base : ImageStorageHorizontal;
import std.experimental.graphic.image.interfaces : imageObject;
size_t dwBmpSize = ((size_.x * 32 + 31) / 32) * 4 * size_.y;
ubyte[] buffer = alloc.makeArray!ubyte(dwBmpSize);
auto storage = imageObject!(ImageStorageHorizontal!RGB8)(size_.x, size_.y, alloc);
winapi.BITMAPINFOHEADER bi;
bi.biSize = winapi.BITMAPINFOHEADER.sizeof;
bi.biWidth = cast(int)size_.x;
bi.biHeight = cast(int)size_.y;
bi.biPlanes = 1;
bi.biBitCount = 32;
bi.biCompression = winapi.BI_RGB;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0;
bi.biClrImportant = 0;
winapi.BITMAPINFO bitmapInfo;
bitmapInfo.bmiHeader = bi;
winapi.GetDIBits(hMemoryDC, hBitmap, 0, cast(int)size_.y, buffer.ptr, &bitmapInfo, winapi.DIB_RGB_COLORS);
size_t x;
size_t y = size_.y-1;
for(size_t i = 0; i < buffer.length; i += 4) {
RGB8 c = RGB8(buffer[i+2], buffer[i+1], buffer[i]);
storage[x, y] = c;
x++;
if (x == size_.x) {
x = 0;
if (y == 0)
break;
y--;
}
}
alloc.dispose(buffer);
return storage;
}
ImageStorage!RGBA8 bitmapToAlphaImage_WinAPI(winapi.HBITMAP hBitmap, winapi.HDC hMemoryDC, vec2!size_t size_, IAllocator alloc) {
import std.experimental.graphic.image.storage.base : ImageStorageHorizontal;
import std.experimental.graphic.image.interfaces : imageObject;
size_t dwBmpSize = ((size_.x * 32 + 31) / 32) * 4 * size_.y;
ubyte[] buffer = alloc.makeArray!ubyte(dwBmpSize);
auto storage = imageObject!(ImageStorageHorizontal!RGBA8)(size_.x, size_.y, alloc);
winapi.BITMAPINFOHEADER bi;
bi.biSize = winapi.BITMAPINFOHEADER.sizeof;
bi.biWidth = cast(int)size_.x;
bi.biHeight = cast(int)size_.y;
bi.biPlanes = 1;
bi.biBitCount = 32;
bi.biCompression = winapi.BI_RGB;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0;
bi.biClrImportant = 0;
winapi.BITMAPINFO bitmapInfo;
bitmapInfo.bmiHeader = bi;
winapi.GetDIBits(hMemoryDC, hBitmap, 0, cast(int)size_.y, buffer.ptr, &bitmapInfo, winapi.DIB_RGB_COLORS);
size_t x;
size_t y = size_.y-1;
for(size_t i = 0; i < buffer.length; i += 4) {
RGBA8 c = RGBA8(buffer[i+2], buffer[i+1], buffer[i], 255);
storage[x, y] = c;
x++;
if (x == size_.x) {
x = 0;
if (y == 0)
break;
y--;
}
}
alloc.dispose(buffer);
return storage;
}
winapi.HBITMAP imageToBitmap_WinAPI(ImageStorage!RGB8 from, winapi.HDC hMemoryDC, IAllocator alloc) {
size_t dwBmpSize = ((from.width * 32 + 31) / 32) * 4 * from.height;
ubyte[] buffer = alloc.makeArray!ubyte(dwBmpSize);
winapi.HICON ret;
size_t x;
size_t y = from.height-1;
for(size_t i = 0; i < buffer.length; i += 4) {
RGB8 c = from[x, y];
buffer[i] = c.b.value;
buffer[i+1] = c.g.value;
buffer[i+2] = c.r.value;
buffer[i+3] = 255;
x++;
if (x == from.width) {
x = 0;
if (y == 0)
break;
y--;
}
}
winapi.HBITMAP hBitmap = winapi.CreateBitmap(cast(uint)from.width, cast(uint)from.height, 1, 32, buffer.ptr);
alloc.dispose(buffer);
return hBitmap;
}
winapi.HBITMAP imageToAlphaBitmap_WinAPI(ImageStorage!RGBA8 from, winapi.HDC hMemoryDC, IAllocator alloc) {
size_t dwBmpSize = ((from.width * 32 + 31) / 32) * 4 * from.height;
ubyte[] buffer = alloc.makeArray!ubyte(dwBmpSize);
winapi.HICON ret;
size_t x;
size_t y = from.height-1;
for(size_t i = 0; i < buffer.length; i += 4) {
RGBA8 c = from[x, y];
buffer[i] = c.b.value;
buffer[i+1] = c.g.value;
buffer[i+2] = c.r.value;
buffer[i+3] = c.a.value;
x++;
if (x == from.width) {
x = 0;
if (y == 0)
break;
y--;
}
}
winapi.HBITMAP hBitmap = winapi.CreateBitmap(cast(uint)from.width, cast(uint)from.height, 1, 32, buffer.ptr);
alloc.dispose(buffer);
return hBitmap;
}
winapi.HBITMAP imageToAlphaBitmap_WinAPI(shared(ImageStorage!RGBA8) from, winapi.HDC hMemoryDC, shared(ISharedAllocator) alloc) {
size_t dwBmpSize = ((from.width * 32 + 31) / 32) * 4 * from.height;
ubyte[] buffer = alloc.makeArray!ubyte(dwBmpSize);
winapi.HICON ret;
size_t x;
size_t y = from.height-1;
for(size_t i = 0; i < buffer.length; i += 4) {
RGBA8 c = from[x, y];
buffer[i] = c.b.value;
buffer[i+1] = c.g.value;
buffer[i+2] = c.r.value;
buffer[i+3] = c.a.value;
x++;
if (x == from.width) {
x = 0;
if (y == 0)
break;
y--;
}
}
winapi.HBITMAP hBitmap = winapi.CreateBitmap(cast(uint)from.width, cast(uint)from.height, 1, 32, buffer.ptr);
alloc.dispose(buffer);
return hBitmap;
}
winapi.HICON imageToIcon_WinAPI(ImageStorage!RGBA8 from, winapi.HDC hMemoryDC, IAllocator alloc) {
winapi.HBITMAP hBitmap = imageToAlphaBitmap_WinAPI(from, hMemoryDC, alloc);
winapi.HICON ret = bitmapToIcon_WinAPI(hBitmap, hMemoryDC, vec2!size_t(from.width, from.height));
scope(exit)
winapi.DeleteObject(hBitmap);
return ret;
}
winapi.HICON imageToIcon_WinAPI(shared(ImageStorage!RGBA8) from, winapi.HDC hMemoryDC, shared(ISharedAllocator) alloc) {
winapi.HBITMAP hBitmap = imageToAlphaBitmap_WinAPI(from, hMemoryDC, alloc);
winapi.HICON ret = bitmapToIcon_WinAPI(hBitmap, hMemoryDC, vec2!size_t(from.width, from.height));
scope(exit)
winapi.DeleteObject(hBitmap);
return ret;
}
winapi.HICON bitmapToIcon_WinAPI(winapi.HBITMAP hBitmap, winapi.HDC hMemoryDC, vec2!size_t size_) {
winapi.HICON ret;
winapi.HBITMAP hbmMask = winapi.CreateCompatibleBitmap(hMemoryDC, cast(uint)size_.x, cast(uint)size_.y);
winapi.ICONINFO ii;
ii.fIcon = true;
ii.hbmColor = hBitmap;
ii.hbmMask = hbmMask;
ret = winapi.CreateIconIndirect(&ii);
winapi.DeleteObject(hbmMask);
return ret;
}
winapi.HBITMAP resizeBitmap_WinAPI(winapi.HBITMAP hBitmap, winapi.HDC hDC, vec2!size_t toSize, vec2!size_t fromSize) {
winapi.HDC hMemDC1 = winapi.CreateCompatibleDC(hDC);
winapi.HBITMAP hBitmap1 = winapi.CreateCompatibleBitmap(hDC, cast(int)toSize.x, cast(int)toSize.y);
winapi.HGDIOBJ hOld1 = winapi.SelectObject(hMemDC1, hBitmap1);
winapi.HDC hMemDC2 = winapi.CreateCompatibleDC(hDC);
winapi.HGDIOBJ hOld2 = winapi.SelectObject(hMemDC2, hBitmap);
winapi.BITMAP bitmap;
winapi.GetObjectW(hBitmap, winapi.BITMAP.sizeof, &bitmap);
winapi.StretchBlt(hMemDC1, 0, 0, cast(int)toSize.x, cast(int)toSize.y, hMemDC2, 0, 0, cast(int)fromSize.x, cast(int)fromSize.y, winapi.SRCCOPY);
winapi.SelectObject(hMemDC1, hOld1);
winapi.SelectObject(hMemDC2, hOld2);
winapi.DeleteDC(hMemDC1);
winapi.DeleteDC(hMemDC2);
return hBitmap1;
}
struct GetDisplays_WinAPI {
import cf.spew.implementation.instance;
IAllocator alloc;
shared(UIInstance) uiInstance;
IDisplay[] displays;
void call() {
winapi.EnumDisplayMonitors(null, null, &callbackGetDisplays_WinAPI, cast(winapi.LPARAM)cast(void*)&this);
}
}
struct GetPrimaryDisplay_WinAPI {
import cf.spew.implementation.instance;
IAllocator alloc;
shared(UIInstance) uiInstance;
IDisplay display;
void call() {
winapi.EnumDisplayMonitors(null, null, &callbackGetPrimaryDisplay_WinAPI, cast(winapi.LPARAM)cast(void*)&this);
}
}
struct GetWindows_WinAPI {
import cf.spew.implementation.instance;
IAllocator alloc;
shared(UIInstance) uiInstance;
IDisplay display;
IWindow[] windows;
void call() {
winapi.EnumWindows(&callbackGetWindows_WinAPI, cast(winapi.LPARAM)&this);
}
}
extern(Windows) {
int callbackGetDisplays_WinAPI(winapi.HMONITOR hMonitor, winapi.HDC, winapi.LPRECT, winapi.LPARAM lParam) nothrow {
import cf.spew.implementation.windowing.display;
GetDisplays_WinAPI* ctx = cast(GetDisplays_WinAPI*)lParam;
try {
DisplayImpl_WinAPI display = ctx.alloc.make!DisplayImpl_WinAPI(hMonitor, ctx.alloc, ctx.uiInstance);
ctx.alloc.expandArray(ctx.displays, 1);
ctx.displays[$-1] = display;
} catch (Exception e) {}
return true;
}
int callbackGetPrimaryDisplay_WinAPI(winapi.HMONITOR hMonitor, winapi.HDC, winapi.LPRECT, winapi.LPARAM lParam) nothrow {
import cf.spew.implementation.windowing.display;
GetPrimaryDisplay_WinAPI* ctx = cast(GetPrimaryDisplay_WinAPI*)lParam;
winapi.MONITORINFOEXA info;
info.cbSize = winapi.MONITORINFOEXA.sizeof;
winapi.GetMonitorInfoA(hMonitor, &info);
if ((info.dwFlags & winapi.MONITORINFOF_PRIMARY) != winapi.MONITORINFOF_PRIMARY) {
return true;
}
try {
ctx.display = ctx.alloc.make!DisplayImpl_WinAPI(hMonitor, ctx.alloc, ctx.uiInstance);
return false;
} catch (Exception e) {}
return true;
}
int callbackGetWindows_WinAPI(winapi.HWND hwnd, winapi.LPARAM lParam) nothrow {
import cf.spew.implementation.windowing.window;
GetWindows_WinAPI* ctx = cast(GetWindows_WinAPI*)lParam;
if (!winapi.IsWindowVisible(hwnd))
return true;
winapi.RECT rect;
winapi.GetWindowRect(hwnd, &rect);
if (rect.right - rect.left == 0 || rect.bottom - rect.top == 0)
return true;
try {
WindowImpl_WinAPI window = ctx.alloc.make!WindowImpl_WinAPI(hwnd, cast(IContext)null, ctx.alloc, ctx.uiInstance);
if (ctx.display is null) {
ctx.alloc.expandArray(ctx.windows, 1);
ctx.windows[$-1] = window;
} else {
auto display2 = window.display;
if (display2 is null) {
ctx.alloc.dispose(window);
return true;
}
if (display2.name == ctx.display.name) {
ctx.alloc.expandArray(ctx.windows, 1);
ctx.windows[$-1] = window;
} else
ctx.alloc.dispose(window);
}
} catch(Exception e) {}
return true;
}
}
}
|
D
|
/home/zzy/Project/os/target/debug/deps/librustversion-7ca47cf6ed1207ae.so: /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/lib.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/attr.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/bound.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/date.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/expr.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/time.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/version.rs /home/zzy/Project/os/target/debug/build/rustversion-364d55f376da15d5/out/version.rs
/home/zzy/Project/os/target/debug/deps/rustversion-7ca47cf6ed1207ae.d: /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/lib.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/attr.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/bound.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/date.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/expr.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/time.rs /home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/version.rs /home/zzy/Project/os/target/debug/build/rustversion-364d55f376da15d5/out/version.rs
/home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/lib.rs:
/home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/attr.rs:
/home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/bound.rs:
/home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/date.rs:
/home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/expr.rs:
/home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/time.rs:
/home/zzy/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rustversion-1.0.3/src/version.rs:
/home/zzy/Project/os/target/debug/build/rustversion-364d55f376da15d5/out/version.rs:
# env-dep:OUT_DIR=/home/zzy/Project/os/target/debug/build/rustversion-364d55f376da15d5/out
|
D
|
module dwt.internal.mozilla.nsIDocShellTreeOwner;
import dwt.internal.mozilla.Common;
import dwt.internal.mozilla.nsID;
import dwt.internal.mozilla.nsISupports;
import dwt.internal.mozilla.nsIDocShellTreeItem;
import dwt.internal.mozilla.nsStringAPI;
/******************************************************************************
******************************************************************************/
const char[] NS_IDOCSHELLTREEOWNER_IID_STR = "9e508466-5ebb-4618-abfa-9ad47bed0b2e";
const nsIID NS_IDOCSHELLTREEOWNER_IID=
{0x9e508466, 0x5ebb, 0x4618,
[ 0xab, 0xfa, 0x9a, 0xd4, 0x7b, 0xed, 0x0b, 0x2e ]};
interface nsIDocShellTreeOwner : nsISupports {
static const char[] IID_STR = NS_IDOCSHELLTREEOWNER_IID_STR;
static const nsIID IID = NS_IDOCSHELLTREEOWNER_IID;
extern(System):
nsresult FindItemWithName(PRUnichar *name, nsIDocShellTreeItem aRequestor, nsIDocShellTreeItem aOriginalRequestor, nsIDocShellTreeItem *_retval);
nsresult ContentShellAdded(nsIDocShellTreeItem aContentShell, PRBool aPrimary, PRUnichar *aID);
nsresult GetPrimaryContentShell(nsIDocShellTreeItem *aPrimaryContentShell);
nsresult SizeShellTo(nsIDocShellTreeItem shell, PRInt32 cx, PRInt32 cy);
nsresult SetPersistence(PRBool aPersistPosition, PRBool aPersistSize, PRBool aPersistSizeMode);
nsresult GetPersistence(PRBool *aPersistPosition, PRBool *aPersistSize, PRBool *aPersistSizeMode);
}
/******************************************************************************
******************************************************************************/
const char[] NS_IDOCSHELLTREEOWNER_MOZILLA_1_8_BRANCH_IID_STR = "3c2a6927-e923-4ea8-bbda-a335c768ce4e";
const nsIID NS_IDOCSHELLTREEOWNER_MOZILLA_1_8_BRANCH_IID=
{0x3c2a6927, 0xe923, 0x4ea8,
[ 0xbb, 0xda, 0xa3, 0x35, 0xc7, 0x68, 0xce, 0x4e ]};
interface nsIDocShellTreeOwner_MOZILLA_1_8_BRANCH : nsIDocShellTreeOwner {
static const char[] IID_STR = NS_IDOCSHELLTREEOWNER_MOZILLA_1_8_BRANCH_IID_STR;
static const nsIID IID = NS_IDOCSHELLTREEOWNER_MOZILLA_1_8_BRANCH_IID;
extern(System):
nsresult ContentShellAdded2(nsIDocShellTreeItem aContentShell, PRBool aPrimary, PRBool aTargetable, nsAString * aID);
nsresult ContentShellRemoved(nsIDocShellTreeItem aContentShell);
}
|
D
|
// Written in the D programming language.
/**
This module implements a variety of type constructors, i.e., templates
that allow construction of new, useful general-purpose types.
$(SCRIPT inhibitQuickIndex = 1;)
$(DIVC quickindex,
$(BOOKTABLE,
$(TR $(TH Category) $(TH Functions))
$(TR $(TD Tuple) $(TD
$(LREF isTuple)
$(LREF Tuple)
$(LREF tuple)
$(LREF reverse)
))
$(TR $(TD Flags) $(TD
$(LREF BitFlags)
$(LREF isBitFlagEnum)
$(LREF Flag)
$(LREF No)
$(LREF Yes)
))
$(TR $(TD Memory allocation) $(TD
$(LREF RefCounted)
$(LREF refCounted)
$(LREF RefCountedAutoInitialize)
$(LREF scoped)
$(LREF Unique)
))
$(TR $(TD Code generation) $(TD
$(LREF AutoImplement)
$(LREF BlackHole)
$(LREF generateAssertTrap)
$(LREF generateEmptyFunction)
$(LREF WhiteHole)
))
$(TR $(TD Nullable) $(TD
$(LREF Nullable)
$(LREF nullable)
$(LREF NullableRef)
$(LREF nullableRef)
))
$(TR $(TD Proxies) $(TD
$(LREF Proxy)
$(LREF rebindable)
$(LREF Rebindable)
$(LREF ReplaceType)
$(LREF unwrap)
$(LREF wrap)
))
$(TR $(TD Types) $(TD
$(LREF alignForSize)
$(LREF Ternary)
$(LREF Typedef)
$(LREF TypedefType)
$(LREF UnqualRef)
))
))
Copyright: Copyright the respective authors, 2008-
License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
Source: $(PHOBOSSRC std/typecons.d)
Authors: $(HTTP erdani.org, Andrei Alexandrescu),
$(HTTP bartoszmilewski.wordpress.com, Bartosz Milewski),
Don Clugston,
Shin Fujishiro,
Kenji Hara
*/
module std.typecons;
import std.format : singleSpec, FormatSpec, formatValue;
import std.meta : AliasSeq, allSatisfy;
import std.range.primitives : isOutputRange;
import std.traits;
import std.internal.attributes : betterC;
///
@safe unittest
{
// value tuples
alias Coord = Tuple!(int, "x", int, "y", int, "z");
Coord c;
c[1] = 1; // access by index
c.z = 1; // access by given name
assert(c == Coord(0, 1, 1));
// names can be omitted
alias DicEntry = Tuple!(string, string);
// tuples can also be constructed on instantiation
assert(tuple(2, 3, 4)[1] == 3);
// construction on instantiation works with names too
assert(tuple!("x", "y", "z")(2, 3, 4).y == 3);
// Rebindable references to const and immutable objects
{
class Widget { void foo() const @safe {} }
const w1 = new Widget, w2 = new Widget;
w1.foo();
// w1 = w2 would not work; can't rebind const object
auto r = Rebindable!(const Widget)(w1);
// invoke method as if r were a Widget object
r.foo();
// rebind r to refer to another object
r = w2;
}
}
/**
Encapsulates unique ownership of a resource.
When a `Unique!T` goes out of scope it will call `destroy`
on the resource `T` that it manages, unless it is transferred.
One important consequence of `destroy` is that it will call the
destructor of the resource `T`. GC-managed references are not
guaranteed to be valid during a destructor call, but other members of
`T`, such as file handles or pointers to `malloc` memory, will
still be valid during the destructor call. This allows the resource
`T` to deallocate or clean up any non-GC resources.
If it is desirable to persist a `Unique!T` outside of its original
scope, then it can be transferred. The transfer can be explicit, by
calling `release`, or implicit, when returning Unique from a
function. The resource `T` can be a polymorphic class object or
instance of an interface, in which case Unique behaves polymorphically
too.
If `T` is a value type, then `Unique!T` will be implemented
as a reference to a `T`.
*/
struct Unique(T)
{
/** Represents a reference to `T`. Resolves to `T*` if `T` is a value type. */
static if (is(T == class) || is(T == interface))
alias RefT = T;
else
alias RefT = T*;
public:
// Deferred in case we get some language support for checking uniqueness.
version (None)
/**
Allows safe construction of `Unique`. It creates the resource and
guarantees unique ownership of it (unless `T` publishes aliases of
`this`).
Note: Nested structs/classes cannot be created.
Params:
args = Arguments to pass to `T`'s constructor.
---
static class C {}
auto u = Unique!(C).create();
---
*/
static Unique!T create(A...)(auto ref A args)
if (__traits(compiles, new T(args)))
{
Unique!T u;
u._p = new T(args);
return u;
}
/**
Constructor that takes an rvalue.
It will ensure uniqueness, as long as the rvalue
isn't just a view on an lvalue (e.g., a cast).
Typical usage:
----
Unique!Foo f = new Foo;
----
*/
this(RefT p)
{
_p = p;
}
/**
Constructor that takes an lvalue. It nulls its source.
The nulling will ensure uniqueness as long as there
are no previous aliases to the source.
*/
this(ref RefT p)
{
_p = p;
p = null;
assert(p is null);
}
/**
Constructor that takes a `Unique` of a type that is convertible to our type.
Typically used to transfer a `Unique` rvalue of derived type to
a `Unique` of base type.
Example:
---
class C : Object {}
Unique!C uc = new C;
Unique!Object uo = uc.release;
---
*/
this(U)(Unique!U u)
if (is(u.RefT:RefT))
{
_p = u._p;
u._p = null;
}
/// Transfer ownership from a `Unique` of a type that is convertible to our type.
void opAssign(U)(Unique!U u)
if (is(u.RefT:RefT))
{
// first delete any resource we own
destroy(this);
_p = u._p;
u._p = null;
}
~this()
{
if (_p !is null)
{
destroy(_p);
_p = null;
}
}
/** Returns whether the resource exists. */
@property bool isEmpty() const
{
return _p is null;
}
/** Transfer ownership to a `Unique` rvalue. Nullifies the current contents.
Same as calling std.algorithm.move on it.
*/
Unique release()
{
import std.algorithm.mutation : move;
return this.move;
}
/** Forwards member access to contents. */
mixin Proxy!_p;
/**
Postblit operator is undefined to prevent the cloning of `Unique` objects.
*/
@disable this(this);
private:
RefT _p;
}
///
@safe unittest
{
static struct S
{
int i;
this(int i){this.i = i;}
}
Unique!S produce()
{
// Construct a unique instance of S on the heap
Unique!S ut = new S(5);
// Implicit transfer of ownership
return ut;
}
// Borrow a unique resource by ref
void increment(ref Unique!S ur)
{
ur.i++;
}
void consume(Unique!S u2)
{
assert(u2.i == 6);
// Resource automatically deleted here
}
Unique!S u1;
assert(u1.isEmpty);
u1 = produce();
increment(u1);
assert(u1.i == 6);
//consume(u1); // Error: u1 is not copyable
// Transfer ownership of the resource
consume(u1.release);
assert(u1.isEmpty);
}
@system unittest
{
// test conversion to base ref
int deleted = 0;
class C
{
~this(){deleted++;}
}
// constructor conversion
Unique!Object u = Unique!C(new C);
static assert(!__traits(compiles, {u = new C;}));
assert(!u.isEmpty);
destroy(u);
assert(deleted == 1);
Unique!C uc = new C;
static assert(!__traits(compiles, {Unique!Object uo = uc;}));
Unique!Object uo = new C;
// opAssign conversion, deleting uo resource first
uo = uc.release;
assert(uc.isEmpty);
assert(!uo.isEmpty);
assert(deleted == 2);
}
@system unittest
{
class Bar
{
~this() { debug(Unique) writeln(" Bar destructor"); }
int val() const { return 4; }
}
alias UBar = Unique!(Bar);
UBar g(UBar u)
{
debug(Unique) writeln("inside g");
return u.release;
}
auto ub = UBar(new Bar);
assert(!ub.isEmpty);
assert(ub.val == 4);
static assert(!__traits(compiles, {auto ub3 = g(ub);}));
auto ub2 = g(ub.release);
assert(ub.isEmpty);
assert(!ub2.isEmpty);
}
@system unittest
{
interface Bar
{
int val() const;
}
class BarImpl : Bar
{
static int count;
this()
{
count++;
}
~this()
{
count--;
}
int val() const { return 4; }
}
alias UBar = Unique!Bar;
UBar g(UBar u)
{
debug(Unique) writeln("inside g");
return u.release;
}
void consume(UBar u)
{
assert(u.val() == 4);
// Resource automatically deleted here
}
auto ub = UBar(new BarImpl);
assert(BarImpl.count == 1);
assert(!ub.isEmpty);
assert(ub.val == 4);
static assert(!__traits(compiles, {auto ub3 = g(ub);}));
auto ub2 = g(ub.release);
assert(ub.isEmpty);
assert(!ub2.isEmpty);
consume(ub2.release);
assert(BarImpl.count == 0);
}
@safe unittest
{
struct Foo
{
~this() { }
int val() const { return 3; }
@disable this(this);
}
alias UFoo = Unique!(Foo);
UFoo f(UFoo u)
{
return u.release;
}
auto uf = UFoo(new Foo);
assert(!uf.isEmpty);
assert(uf.val == 3);
static assert(!__traits(compiles, {auto uf3 = f(uf);}));
auto uf2 = f(uf.release);
assert(uf.isEmpty);
assert(!uf2.isEmpty);
}
// ensure Unique behaves correctly through const access paths
@system unittest
{
struct Bar {int val;}
struct Foo
{
Unique!Bar bar = new Bar;
}
Foo foo;
foo.bar.val = 6;
const Foo* ptr = &foo;
static assert(is(typeof(ptr) == const(Foo*)));
static assert(is(typeof(ptr.bar) == const(Unique!Bar)));
static assert(is(typeof(ptr.bar.val) == const(int)));
assert(ptr.bar.val == 6);
foo.bar.val = 7;
assert(ptr.bar.val == 7);
}
// Used in Tuple.toString
private template sharedToString(alias field)
if (is(typeof(field) == shared))
{
static immutable sharedToString = typeof(field).stringof;
}
private template sharedToString(alias field)
if (!is(typeof(field) == shared))
{
alias sharedToString = field;
}
private enum bool distinctFieldNames(names...) = __traits(compiles,
{
static foreach (__name; names)
static if (is(typeof(__name) : string))
mixin("enum int " ~ __name ~ " = 0;");
});
@safe unittest
{
static assert(!distinctFieldNames!(string, "abc", string, "abc"));
static assert(distinctFieldNames!(string, "abc", int, "abd"));
static assert(!distinctFieldNames!(int, "abc", string, "abd", int, "abc"));
// https://issues.dlang.org/show_bug.cgi?id=19240
static assert(!distinctFieldNames!(int, "int"));
}
/**
_Tuple of values, for example $(D Tuple!(int, string)) is a record that
stores an `int` and a `string`. `Tuple` can be used to bundle
values together, notably when returning multiple values from a
function. If `obj` is a `Tuple`, the individual members are
accessible with the syntax `obj[0]` for the first field, `obj[1]`
for the second, and so on.
See_Also: $(LREF tuple).
Params:
Specs = A list of types (and optionally, member names) that the `Tuple` contains.
*/
template Tuple(Specs...)
if (distinctFieldNames!(Specs))
{
import std.meta : staticMap;
// Parse (type,name) pairs (FieldSpecs) out of the specified
// arguments. Some fields would have name, others not.
template parseSpecs(Specs...)
{
static if (Specs.length == 0)
{
alias parseSpecs = AliasSeq!();
}
else static if (is(Specs[0]))
{
static if (is(typeof(Specs[1]) : string))
{
alias parseSpecs =
AliasSeq!(FieldSpec!(Specs[0 .. 2]),
parseSpecs!(Specs[2 .. $]));
}
else
{
alias parseSpecs =
AliasSeq!(FieldSpec!(Specs[0]),
parseSpecs!(Specs[1 .. $]));
}
}
else
{
static assert(0, "Attempted to instantiate Tuple with an "
~"invalid argument: "~ Specs[0].stringof);
}
}
template FieldSpec(T, string s = "")
{
alias Type = T;
alias name = s;
}
alias fieldSpecs = parseSpecs!Specs;
// Used with staticMap.
alias extractType(alias spec) = spec.Type;
alias extractName(alias spec) = spec.name;
// Generates named fields as follows:
// alias name_0 = Identity!(field[0]);
// alias name_1 = Identity!(field[1]);
// :
// NOTE: field[k] is an expression (which yields a symbol of a
// variable) and can't be aliased directly.
enum injectNamedFields = ()
{
string decl = "";
static foreach (i, val; fieldSpecs)
{{
immutable si = i.stringof;
decl ~= "alias _" ~ si ~ " = Identity!(field[" ~ si ~ "]);";
if (val.name.length != 0)
{
decl ~= "alias " ~ val.name ~ " = _" ~ si ~ ";";
}
}}
return decl;
};
// Returns Specs for a subtuple this[from .. to] preserving field
// names if any.
alias sliceSpecs(size_t from, size_t to) =
staticMap!(expandSpec, fieldSpecs[from .. to]);
template expandSpec(alias spec)
{
static if (spec.name.length == 0)
{
alias expandSpec = AliasSeq!(spec.Type);
}
else
{
alias expandSpec = AliasSeq!(spec.Type, spec.name);
}
}
enum areCompatibleTuples(Tup1, Tup2, string op) = isTuple!(OriginalType!Tup2) && is(typeof(
(ref Tup1 tup1, ref Tup2 tup2)
{
static assert(tup1.field.length == tup2.field.length);
static foreach (i; 0 .. Tup1.Types.length)
{{
auto lhs = typeof(tup1.field[i]).init;
auto rhs = typeof(tup2.field[i]).init;
static if (op == "=")
lhs = rhs;
else
auto result = mixin("lhs "~op~" rhs");
}}
}));
enum areBuildCompatibleTuples(Tup1, Tup2) = isTuple!Tup2 && is(typeof(
{
static assert(Tup1.Types.length == Tup2.Types.length);
static foreach (i; 0 .. Tup1.Types.length)
static assert(isBuildable!(Tup1.Types[i], Tup2.Types[i]));
}));
/+ Returns `true` iff a `T` can be initialized from a `U`. +/
enum isBuildable(T, U) = is(typeof(
{
U u = U.init;
T t = u;
}));
/+ Helper for partial instantiation +/
template isBuildableFrom(U)
{
enum isBuildableFrom(T) = isBuildable!(T, U);
}
struct Tuple
{
/**
* The types of the `Tuple`'s components.
*/
alias Types = staticMap!(extractType, fieldSpecs);
private alias _Fields = Specs;
///
static if (Specs.length == 0) @safe unittest
{
import std.meta : AliasSeq;
alias Fields = Tuple!(int, "id", string, float);
static assert(is(Fields.Types == AliasSeq!(int, string, float)));
}
/**
* The names of the `Tuple`'s components. Unnamed fields have empty names.
*/
alias fieldNames = staticMap!(extractName, fieldSpecs);
///
static if (Specs.length == 0) @safe unittest
{
import std.meta : AliasSeq;
alias Fields = Tuple!(int, "id", string, float);
static assert(Fields.fieldNames == AliasSeq!("id", "", ""));
}
/**
* Use `t.expand` for a `Tuple` `t` to expand it into its
* components. The result of `expand` acts as if the `Tuple`'s components
* were listed as a list of values. (Ordinarily, a `Tuple` acts as a
* single value.)
*/
Types expand;
mixin(injectNamedFields());
///
static if (Specs.length == 0) @safe unittest
{
auto t1 = tuple(1, " hello ", 'a');
assert(t1.toString() == `Tuple!(int, string, char)(1, " hello ", 'a')`);
void takeSeveralTypes(int n, string s, bool b)
{
assert(n == 4 && s == "test" && b == false);
}
auto t2 = tuple(4, "test", false);
//t.expand acting as a list of values
takeSeveralTypes(t2.expand);
}
static if (is(Specs))
{
// This is mostly to make t[n] work.
alias expand this;
}
else
{
@property
ref inout(Tuple!Types) _Tuple_super() inout @trusted
{
static foreach (i; 0 .. Types.length) // Rely on the field layout
{
static assert(typeof(return).init.tupleof[i].offsetof ==
expand[i].offsetof);
}
return *cast(typeof(return)*) &(field[0]);
}
// This is mostly to make t[n] work.
alias _Tuple_super this;
}
// backwards compatibility
alias field = expand;
/**
* Constructor taking one value for each field.
*
* Params:
* values = A list of values that are either the same
* types as those given by the `Types` field
* of this `Tuple`, or can implicitly convert
* to those types. They must be in the same
* order as they appear in `Types`.
*/
static if (Types.length > 0)
{
this(Types values)
{
field[] = values[];
}
}
///
static if (Specs.length == 0) @safe unittest
{
alias ISD = Tuple!(int, string, double);
auto tup = ISD(1, "test", 3.2);
assert(tup.toString() == `Tuple!(int, string, double)(1, "test", 3.2)`);
}
/**
* Constructor taking a compatible array.
*
* Params:
* values = A compatible static array to build the `Tuple` from.
* Array slices are not supported.
*/
this(U, size_t n)(U[n] values)
if (n == Types.length && allSatisfy!(isBuildableFrom!U, Types))
{
static foreach (i; 0 .. Types.length)
{
field[i] = values[i];
}
}
///
static if (Specs.length == 0) @safe unittest
{
int[2] ints;
Tuple!(int, int) t = ints;
}
/**
* Constructor taking a compatible `Tuple`. Two `Tuple`s are compatible
* $(B iff) they are both of the same length, and, for each type `T` on the
* left-hand side, the corresponding type `U` on the right-hand side can
* implicitly convert to `T`.
*
* Params:
* another = A compatible `Tuple` to build from. Its type must be
* compatible with the target `Tuple`'s type.
*/
this(U)(U another)
if (areBuildCompatibleTuples!(typeof(this), U))
{
field[] = another.field[];
}
///
static if (Specs.length == 0) @safe unittest
{
alias IntVec = Tuple!(int, int, int);
alias DubVec = Tuple!(double, double, double);
IntVec iv = tuple(1, 1, 1);
//Ok, int can implicitly convert to double
DubVec dv = iv;
//Error: double cannot implicitly convert to int
//IntVec iv2 = dv;
}
/**
* Comparison for equality. Two `Tuple`s are considered equal
* $(B iff) they fulfill the following criteria:
*
* $(UL
* $(LI Each `Tuple` is the same length.)
* $(LI For each type `T` on the left-hand side and each type
* `U` on the right-hand side, values of type `T` can be
* compared with values of type `U`.)
* $(LI For each value `v1` on the left-hand side and each value
* `v2` on the right-hand side, the expression `v1 == v2` is
* true.))
*
* Params:
* rhs = The `Tuple` to compare against. It must meeting the criteria
* for comparison between `Tuple`s.
*
* Returns:
* true if both `Tuple`s are equal, otherwise false.
*/
bool opEquals(R)(R rhs)
if (areCompatibleTuples!(typeof(this), R, "=="))
{
return field[] == rhs.field[];
}
/// ditto
bool opEquals(R)(R rhs) const
if (areCompatibleTuples!(typeof(this), R, "=="))
{
return field[] == rhs.field[];
}
/// ditto
bool opEquals(R...)(auto ref R rhs)
if (R.length > 1 && areCompatibleTuples!(typeof(this), Tuple!R, "=="))
{
static foreach (i; 0 .. Types.length)
if (field[i] != rhs[i])
return false;
return true;
}
///
static if (Specs.length == 0) @safe unittest
{
Tuple!(int, string) t1 = tuple(1, "test");
Tuple!(double, string) t2 = tuple(1.0, "test");
//Ok, int can be compared with double and
//both have a value of 1
assert(t1 == t2);
}
/**
* Comparison for ordering.
*
* Params:
* rhs = The `Tuple` to compare against. It must meet the criteria
* for comparison between `Tuple`s.
*
* Returns:
* For any values `v1` contained by the left-hand side tuple and any
* values `v2` contained by the right-hand side:
*
* 0 if `v1 == v2` for all members or the following value for the
* first position were the mentioned criteria is not satisfied:
*
* $(UL
* $(LI NaN, in case one of the operands is a NaN.)
* $(LI A negative number if the expression `v1 < v2` is true.)
* $(LI A positive number if the expression `v1 > v2` is true.))
*/
auto opCmp(R)(R rhs)
if (areCompatibleTuples!(typeof(this), R, "<"))
{
static foreach (i; 0 .. Types.length)
{
if (field[i] != rhs.field[i])
{
import std.math : isNaN;
static if (isFloatingPoint!(Types[i]))
{
if (isNaN(field[i]))
return float.nan;
}
static if (isFloatingPoint!(typeof(rhs.field[i])))
{
if (isNaN(rhs.field[i]))
return float.nan;
}
static if (is(typeof(field[i].opCmp(rhs.field[i]))) &&
isFloatingPoint!(typeof(field[i].opCmp(rhs.field[i]))))
{
if (isNaN(field[i].opCmp(rhs.field[i])))
return float.nan;
}
return field[i] < rhs.field[i] ? -1 : 1;
}
}
return 0;
}
/// ditto
auto opCmp(R)(R rhs) const
if (areCompatibleTuples!(typeof(this), R, "<"))
{
static foreach (i; 0 .. Types.length)
{
if (field[i] != rhs.field[i])
{
import std.math : isNaN;
static if (isFloatingPoint!(Types[i]))
{
if (isNaN(field[i]))
return float.nan;
}
static if (isFloatingPoint!(typeof(rhs.field[i])))
{
if (isNaN(rhs.field[i]))
return float.nan;
}
static if (is(typeof(field[i].opCmp(rhs.field[i]))) &&
isFloatingPoint!(typeof(field[i].opCmp(rhs.field[i]))))
{
if (isNaN(field[i].opCmp(rhs.field[i])))
return float.nan;
}
return field[i] < rhs.field[i] ? -1 : 1;
}
}
return 0;
}
/**
The first `v1` for which `v1 > v2` is true determines
the result. This could lead to unexpected behaviour.
*/
static if (Specs.length == 0) @safe unittest
{
auto tup1 = tuple(1, 1, 1);
auto tup2 = tuple(1, 100, 100);
assert(tup1 < tup2);
//Only the first result matters for comparison
tup1[0] = 2;
assert(tup1 > tup2);
}
/**
Concatenate Tuples.
Tuple concatenation is only allowed if all named fields are distinct (no named field of this tuple occurs in `t`
and no named field of `t` occurs in this tuple).
Params:
t = The `Tuple` to concatenate with
Returns: A concatenation of this tuple and `t`
*/
auto opBinary(string op, T)(auto ref T t)
if (op == "~" && !(is(T : U[], U) && isTuple!U))
{
static if (isTuple!T)
{
static assert(distinctFieldNames!(_Fields, T._Fields),
"Cannot concatenate tuples with duplicate fields: " ~ fieldNames.stringof ~
" - " ~ T.fieldNames.stringof);
return Tuple!(_Fields, T._Fields)(expand, t.expand);
}
else
{
return Tuple!(_Fields, T)(expand, t);
}
}
/// ditto
auto opBinaryRight(string op, T)(auto ref T t)
if (op == "~" && !(is(T : U[], U) && isTuple!U))
{
static if (isTuple!T)
{
static assert(distinctFieldNames!(_Fields, T._Fields),
"Cannot concatenate tuples with duplicate fields: " ~ T.stringof ~
" - " ~ fieldNames.fieldNames.stringof);
return Tuple!(T._Fields, _Fields)(t.expand, expand);
}
else
{
return Tuple!(T, _Fields)(t, expand);
}
}
/**
* Assignment from another `Tuple`.
*
* Params:
* rhs = The source `Tuple` to assign from. Each element of the
* source `Tuple` must be implicitly assignable to each
* respective element of the target `Tuple`.
*/
ref Tuple opAssign(R)(auto ref R rhs)
if (areCompatibleTuples!(typeof(this), R, "="))
{
import std.algorithm.mutation : swap;
static if (is(R : Tuple!Types) && !__traits(isRef, rhs) && isTuple!R)
{
if (__ctfe)
{
// Cannot use swap at compile time
field[] = rhs.field[];
}
else
{
// Use swap-and-destroy to optimize rvalue assignment
swap!(Tuple!Types)(this, rhs);
}
}
else
{
// Do not swap; opAssign should be called on the fields.
field[] = rhs.field[];
}
return this;
}
/**
* Renames the elements of a $(LREF Tuple).
*
* `rename` uses the passed `names` and returns a new
* $(LREF Tuple) using these names, with the content
* unchanged.
* If fewer names are passed than there are members
* of the $(LREF Tuple) then those trailing members are unchanged.
* An empty string will remove the name for that member.
* It is an compile-time error to pass more names than
* there are members of the $(LREF Tuple).
*/
ref rename(names...)() inout return
if (names.length == 0 || allSatisfy!(isSomeString, typeof(names)))
{
import std.algorithm.comparison : equal;
// to circumvent https://issues.dlang.org/show_bug.cgi?id=16418
static if (names.length == 0 || equal([names], [fieldNames]))
return this;
else
{
enum nT = Types.length;
enum nN = names.length;
static assert(nN <= nT, "Cannot have more names than tuple members");
alias allNames = AliasSeq!(names, fieldNames[nN .. $]);
import std.meta : Alias, aliasSeqOf;
template GetItem(size_t idx)
{
import std.array : empty;
static if (idx < nT)
alias GetItem = Alias!(Types[idx]);
else static if (allNames[idx - nT].empty)
alias GetItem = AliasSeq!();
else
alias GetItem = Alias!(allNames[idx - nT]);
}
import std.range : roundRobin, iota;
alias NewTupleT = Tuple!(staticMap!(GetItem, aliasSeqOf!(
roundRobin(iota(nT), iota(nT, 2*nT)))));
return *(() @trusted => cast(NewTupleT*)&this)();
}
}
///
static if (Specs.length == 0) @safe unittest
{
auto t0 = tuple(4, "hello");
auto t0Named = t0.rename!("val", "tag");
assert(t0Named.val == 4);
assert(t0Named.tag == "hello");
Tuple!(float, "dat", size_t[2], "pos") t1;
t1.pos = [2, 1];
auto t1Named = t1.rename!"height";
t1Named.height = 3.4f;
assert(t1Named.height == 3.4f);
assert(t1Named.pos == [2, 1]);
t1Named.rename!"altitude".altitude = 5;
assert(t1Named.height == 5);
Tuple!(int, "a", int, int, "c") t2;
t2 = tuple(3,4,5);
auto t2Named = t2.rename!("", "b");
// "a" no longer has a name
static assert(!__traits(hasMember, typeof(t2Named), "a"));
assert(t2Named[0] == 3);
assert(t2Named.b == 4);
assert(t2Named.c == 5);
// not allowed to specify more names than the tuple has members
static assert(!__traits(compiles, t2.rename!("a","b","c","d")));
// use it in a range pipeline
import std.range : iota, zip;
import std.algorithm.iteration : map, sum;
auto res = zip(iota(1, 4), iota(10, 13))
.map!(t => t.rename!("a", "b"))
.map!(t => t.a * t.b)
.sum;
assert(res == 68);
const tup = Tuple!(int, "a", int, "b")(2, 3);
const renamed = tup.rename!("c", "d");
assert(renamed.c + renamed.d == 5);
}
/**
* Overload of $(LREF _rename) that takes an associative array
* `translate` as a template parameter, where the keys are
* either the names or indices of the members to be changed
* and the new names are the corresponding values.
* Every key in `translate` must be the name of a member of the
* $(LREF tuple).
* The same rules for empty strings apply as for the variadic
* template overload of $(LREF _rename).
*/
ref rename(alias translate)() inout
if (is(typeof(translate) : V[K], V, K) && isSomeString!V &&
(isSomeString!K || is(K : size_t)))
{
import std.meta : aliasSeqOf;
import std.range : ElementType;
static if (isSomeString!(ElementType!(typeof(translate.keys))))
{
{
import std.conv : to;
import std.algorithm.iteration : filter;
import std.algorithm.searching : canFind;
enum notFound = translate.keys
.filter!(k => fieldNames.canFind(k) == -1);
static assert(notFound.empty, "Cannot find members "
~ notFound.to!string ~ " in type "
~ typeof(this).stringof);
}
return this.rename!(aliasSeqOf!(
{
import std.array : empty;
auto names = [fieldNames];
foreach (ref n; names)
if (!n.empty)
if (auto p = n in translate)
n = *p;
return names;
}()));
}
else
{
{
import std.algorithm.iteration : filter;
import std.conv : to;
enum invalid = translate.keys.
filter!(k => k < 0 || k >= this.length);
static assert(invalid.empty, "Indices " ~ invalid.to!string
~ " are out of bounds for tuple with length "
~ this.length.to!string);
}
return this.rename!(aliasSeqOf!(
{
auto names = [fieldNames];
foreach (k, v; translate)
names[k] = v;
return names;
}()));
}
}
///
static if (Specs.length == 0) @safe unittest
{
//replacing names by their current name
Tuple!(float, "dat", size_t[2], "pos") t1;
t1.pos = [2, 1];
auto t1Named = t1.rename!(["dat": "height"]);
t1Named.height = 3.4;
assert(t1Named.pos == [2, 1]);
t1Named.rename!(["height": "altitude"]).altitude = 5;
assert(t1Named.height == 5);
Tuple!(int, "a", int, "b") t2;
t2 = tuple(3, 4);
auto t2Named = t2.rename!(["a": "b", "b": "c"]);
assert(t2Named.b == 3);
assert(t2Named.c == 4);
const t3 = Tuple!(int, "a", int, "b")(3, 4);
const t3Named = t3.rename!(["a": "b", "b": "c"]);
assert(t3Named.b == 3);
assert(t3Named.c == 4);
}
///
static if (Specs.length == 0) @safe unittest
{
//replace names by their position
Tuple!(float, "dat", size_t[2], "pos") t1;
t1.pos = [2, 1];
auto t1Named = t1.rename!([0: "height"]);
t1Named.height = 3.4;
assert(t1Named.pos == [2, 1]);
t1Named.rename!([0: "altitude"]).altitude = 5;
assert(t1Named.height == 5);
Tuple!(int, "a", int, "b", int, "c") t2;
t2 = tuple(3, 4, 5);
auto t2Named = t2.rename!([0: "c", 2: "a"]);
assert(t2Named.a == 5);
assert(t2Named.b == 4);
assert(t2Named.c == 3);
}
static if (Specs.length == 0) @safe unittest
{
//check that empty translations work fine
enum string[string] a0 = null;
enum string[int] a1 = null;
Tuple!(float, "a", float, "b") t0;
auto t1 = t0.rename!a0;
t1.a = 3;
t1.b = 4;
auto t2 = t0.rename!a1;
t2.a = 3;
t2.b = 4;
auto t3 = t0.rename;
t3.a = 3;
t3.b = 4;
}
/**
* Takes a slice by-reference of this `Tuple`.
*
* Params:
* from = A `size_t` designating the starting position of the slice.
* to = A `size_t` designating the ending position (exclusive) of the slice.
*
* Returns:
* A new `Tuple` that is a slice from `[from, to$(RPAREN)` of the original.
* It has the same types and values as the range `[from, to$(RPAREN)` in
* the original.
*/
@property
ref inout(Tuple!(sliceSpecs!(from, to))) slice(size_t from, size_t to)() inout @trusted
if (from <= to && to <= Types.length)
{
static assert(
(typeof(this).alignof % typeof(return).alignof == 0) &&
(expand[from].offsetof % typeof(return).alignof == 0),
"Slicing by reference is impossible because of an alignment mistmatch" ~
" (See https://issues.dlang.org/show_bug.cgi?id=15645).");
return *cast(typeof(return)*) &(field[from]);
}
///
static if (Specs.length == 0) @safe unittest
{
Tuple!(int, string, float, double) a;
a[1] = "abc";
a[2] = 4.5;
auto s = a.slice!(1, 3);
static assert(is(typeof(s) == Tuple!(string, float)));
assert(s[0] == "abc" && s[1] == 4.5);
// https://issues.dlang.org/show_bug.cgi?id=15645
Tuple!(int, short, bool, double) b;
static assert(!__traits(compiles, b.slice!(2, 4)));
}
/**
Creates a hash of this `Tuple`.
Returns:
A `size_t` representing the hash of this `Tuple`.
*/
size_t toHash() const nothrow @safe
{
size_t h = 0;
static foreach (i, T; Types)
{{
static if (__traits(compiles, h = .hashOf(field[i])))
const k = .hashOf(field[i]);
else
{
// Workaround for when .hashOf is not both @safe and nothrow.
static if (is(T : shared U, U) && __traits(compiles, (U* a) nothrow @safe => .hashOf(*a))
&& !__traits(hasMember, T, "toHash"))
// BUG: Improperly casts away `shared`!
const k = .hashOf(*(() @trusted => cast(U*) &field[i])());
else
// BUG: Improperly casts away `shared`!
const k = typeid(T).getHash((() @trusted => cast(const void*) &field[i])());
}
static if (i == 0)
h = k;
else
// As in boost::hash_combine
// https://www.boost.org/doc/libs/1_55_0/doc/html/hash/reference.html#boost.hash_combine
h ^= k + 0x9e3779b9 + (h << 6) + (h >>> 2);
}}
return h;
}
/**
* Converts to string.
*
* Returns:
* The string representation of this `Tuple`.
*/
string toString()() const
{
import std.array : appender;
auto app = appender!string();
this.toString((const(char)[] chunk) => app ~= chunk);
return app.data;
}
import std.format : FormatSpec;
/**
* Formats `Tuple` with either `%s`, `%(inner%)` or `%(inner%|sep%)`.
*
* $(TABLE2 Formats supported by Tuple,
* $(THEAD Format, Description)
* $(TROW $(P `%s`), $(P Format like `Tuple!(types)(elements formatted with %s each)`.))
* $(TROW $(P `%(inner%)`), $(P The format `inner` is applied the expanded `Tuple`$(COMMA) so
* it may contain as many formats as the `Tuple` has fields.))
* $(TROW $(P `%(inner%|sep%)`), $(P The format `inner` is one format$(COMMA) that is applied
* on all fields of the `Tuple`. The inner format must be compatible to all
* of them.)))
*
* Params:
* sink = A `char` accepting delegate
* fmt = A $(REF FormatSpec, std,format)
*/
void toString(DG)(scope DG sink) const
{
auto f = FormatSpec!char();
toString(sink, f);
}
/// ditto
void toString(DG, Char)(scope DG sink, scope const ref FormatSpec!Char fmt) const
{
import std.format : formatElement, formattedWrite, FormatException;
if (fmt.nested)
{
if (fmt.sep)
{
foreach (i, Type; Types)
{
static if (i > 0)
{
sink(fmt.sep);
}
// TODO: Change this once formattedWrite() works for shared objects.
static if (is(Type == class) && is(Type == shared))
{
sink(Type.stringof);
}
else
{
formattedWrite(sink, fmt.nested, this.field[i]);
}
}
}
else
{
formattedWrite(sink, fmt.nested, staticMap!(sharedToString, this.expand));
}
}
else if (fmt.spec == 's')
{
enum header = Unqual!(typeof(this)).stringof ~ "(",
footer = ")",
separator = ", ";
sink(header);
foreach (i, Type; Types)
{
static if (i > 0)
{
sink(separator);
}
// TODO: Change this once formatElement() works for shared objects.
static if (is(Type == class) && is(Type == shared))
{
sink(Type.stringof);
}
else
{
FormatSpec!Char f;
formatElement(sink, field[i], f);
}
}
sink(footer);
}
else
{
const spec = fmt.spec;
throw new FormatException(
"Expected '%s' or '%(...%)' or '%(...%|...%)' format specifier for type '" ~
Unqual!(typeof(this)).stringof ~ "', not '%" ~ spec ~ "'.");
}
}
///
static if (Types.length == 0)
@safe unittest
{
import std.format : format;
Tuple!(int, double)[3] tupList = [ tuple(1, 1.0), tuple(2, 4.0), tuple(3, 9.0) ];
// Default format
assert(format("%s", tuple("a", 1)) == `Tuple!(string, int)("a", 1)`);
// One Format for each individual component
assert(format("%(%#x v %.4f w %#x%)", tuple(1, 1.0, 10)) == `0x1 v 1.0000 w 0xa`);
assert(format( "%#x v %.4f w %#x" , tuple(1, 1.0, 10).expand) == `0x1 v 1.0000 w 0xa`);
// One Format for all components
assert(format("%(>%s<%| & %)", tuple("abc", 1, 2.3, [4, 5])) == `>abc< & >1< & >2.3< & >[4, 5]<`);
// Array of Tuples
assert(format("%(%(f(%d) = %.1f%); %)", tupList) == `f(1) = 1.0; f(2) = 4.0; f(3) = 9.0`);
}
///
static if (Types.length == 0)
@safe unittest
{
import std.exception : assertThrown;
import std.format : format, FormatException;
// Error: %( %) missing.
assertThrown!FormatException(
format("%d, %f", tuple(1, 2.0)) == `1, 2.0`
);
// Error: %( %| %) missing.
assertThrown!FormatException(
format("%d", tuple(1, 2)) == `1, 2`
);
// Error: %d inadequate for double
assertThrown!FormatException(
format("%(%d%|, %)", tuple(1, 2.0)) == `1, 2.0`
);
}
}
}
///
@safe unittest
{
Tuple!(int, int) point;
// assign coordinates
point[0] = 5;
point[1] = 6;
// read coordinates
auto x = point[0];
auto y = point[1];
}
/**
`Tuple` members can be named. It is legal to mix named and unnamed
members. The method above is still applicable to all fields.
*/
@safe unittest
{
alias Entry = Tuple!(int, "index", string, "value");
Entry e;
e.index = 4;
e.value = "Hello";
assert(e[1] == "Hello");
assert(e[0] == 4);
}
/**
A `Tuple` with named fields is a distinct type from a `Tuple` with unnamed
fields, i.e. each naming imparts a separate type for the `Tuple`. Two
`Tuple`s differing in naming only are still distinct, even though they
might have the same structure.
*/
@safe unittest
{
Tuple!(int, "x", int, "y") point1;
Tuple!(int, int) point2;
assert(!is(typeof(point1) == typeof(point2)));
}
/// Use tuples as ranges
@safe unittest
{
import std.algorithm.iteration : sum;
import std.range : only;
auto t = tuple(1, 2);
assert(t.expand.only.sum == 3);
}
// https://issues.dlang.org/show_bug.cgi?id=4582
@safe unittest
{
static assert(!__traits(compiles, Tuple!(string, "id", int, "id")));
static assert(!__traits(compiles, Tuple!(string, "str", int, "i", string, "str", float)));
}
/// Concatenate tuples
@safe unittest
{
import std.meta : AliasSeq;
auto t = tuple(1, "2") ~ tuple(ushort(42), true);
static assert(is(t.Types == AliasSeq!(int, string, ushort, bool)));
assert(t[1] == "2");
assert(t[2] == 42);
assert(t[3] == true);
}
// https://issues.dlang.org/show_bug.cgi?id=14637
// tuple concat
@safe unittest
{
auto t = tuple!"foo"(1.0) ~ tuple!"bar"("3");
static assert(is(t.Types == AliasSeq!(double, string)));
static assert(t.fieldNames == tuple("foo", "bar"));
assert(t.foo == 1.0);
assert(t.bar == "3");
}
// https://issues.dlang.org/show_bug.cgi?id=18824
// tuple concat
@safe unittest
{
alias Type = Tuple!(int, string);
Type[] arr;
auto t = tuple(2, "s");
// Test opBinaryRight
arr = arr ~ t;
// Test opBinary
arr = t ~ arr;
static assert(is(typeof(arr) == Type[]));
immutable Type[] b;
auto c = b ~ t;
static assert(is(typeof(c) == immutable(Type)[]));
}
// tuple concat
@safe unittest
{
auto t = tuple!"foo"(1.0) ~ "3";
static assert(is(t.Types == AliasSeq!(double, string)));
assert(t.foo == 1.0);
assert(t[1]== "3");
}
// tuple concat
@safe unittest
{
auto t = "2" ~ tuple!"foo"(1.0);
static assert(is(t.Types == AliasSeq!(string, double)));
assert(t.foo == 1.0);
assert(t[0]== "2");
}
// tuple concat
@safe unittest
{
auto t = "2" ~ tuple!"foo"(1.0) ~ tuple(42, 3.0f) ~ real(1) ~ "a";
static assert(is(t.Types == AliasSeq!(string, double, int, float, real, string)));
assert(t.foo == 1.0);
assert(t[0] == "2");
assert(t[1] == 1.0);
assert(t[2] == 42);
assert(t[3] == 3.0f);
assert(t[4] == 1.0);
assert(t[5] == "a");
}
// ensure that concatenation of tuples with non-distinct fields is forbidden
@safe unittest
{
static assert(!__traits(compiles,
tuple!("a")(0) ~ tuple!("a")("1")));
static assert(!__traits(compiles,
tuple!("a", "b")(0, 1) ~ tuple!("b", "a")("3", 1)));
static assert(!__traits(compiles,
tuple!("a")(0) ~ tuple!("b", "a")("3", 1)));
static assert(!__traits(compiles,
tuple!("a1", "a")(1.0, 0) ~ tuple!("a2", "a")("3", 0)));
}
// Ensure that Tuple comparison with non-const opEquals works
@safe unittest
{
static struct Bad
{
int a;
bool opEquals(Bad b)
{
return a == b.a;
}
}
auto t = Tuple!(int, Bad, string)(1, Bad(1), "asdf");
//Error: mutable method Bad.opEquals is not callable using a const object
assert(t == AliasSeq!(1, Bad(1), "asdf"));
}
// Ensure Tuple.toHash works
@safe unittest
{
Tuple!(int, int) point;
assert(point.toHash == typeof(point).init.toHash);
assert(tuple(1, 2) != point);
assert(tuple(1, 2) == tuple(1, 2));
point[0] = 1;
assert(tuple(1, 2) != point);
point[1] = 2;
assert(tuple(1, 2) == point);
}
@safe @betterC unittest
{
auto t = tuple(1, 2);
assert(t == tuple(1, 2));
auto t3 = tuple(1, 'd');
}
// https://issues.dlang.org/show_bug.cgi?id=20850
// Assignment to enum tuple
@safe unittest
{
enum T : Tuple!(int*) { a = T(null) }
T t;
t = T.a;
}
// https://issues.dlang.org/show_bug.cgi?id=13663
@safe unittest
{
auto t = tuple(real.nan);
assert(!(t > t));
assert(!(t < t));
assert(!(t == t));
}
@safe unittest
{
struct S
{
float opCmp(S s) { return float.nan; }
bool opEquals(S s) { return false; }
}
auto t = tuple(S());
assert(!(t > t));
assert(!(t < t));
assert(!(t == t));
}
/**
Creates a copy of a $(LREF Tuple) with its fields in _reverse order.
Params:
t = The `Tuple` to copy.
Returns:
A new `Tuple`.
*/
auto reverse(T)(T t)
if (isTuple!T)
{
import std.meta : Reverse;
// @@@BUG@@@ Cannot be an internal function due to forward reference issues.
// @@@BUG@@@ 9929 Need 'this' when calling template with expanded tuple
// return tuple(Reverse!(t.expand));
ReverseTupleType!T result;
auto tup = t.expand;
result.expand = Reverse!tup;
return result;
}
///
@safe unittest
{
auto tup = tuple(1, "2");
assert(tup.reverse == tuple("2", 1));
}
/* Get a Tuple type with the reverse specification of Tuple T. */
private template ReverseTupleType(T)
if (isTuple!T)
{
static if (is(T : Tuple!A, A...))
alias ReverseTupleType = Tuple!(ReverseTupleSpecs!A);
}
/* Reverse the Specs of a Tuple. */
private template ReverseTupleSpecs(T...)
{
static if (T.length > 1)
{
static if (is(typeof(T[$-1]) : string))
{
alias ReverseTupleSpecs = AliasSeq!(T[$-2], T[$-1], ReverseTupleSpecs!(T[0 .. $-2]));
}
else
{
alias ReverseTupleSpecs = AliasSeq!(T[$-1], ReverseTupleSpecs!(T[0 .. $-1]));
}
}
else
{
alias ReverseTupleSpecs = T;
}
}
// ensure that internal Tuple unittests are compiled
@safe unittest
{
Tuple!() t;
}
@safe unittest
{
import std.conv;
{
Tuple!(int, "a", int, "b") nosh;
static assert(nosh.length == 2);
nosh.a = 5;
nosh.b = 6;
assert(nosh.a == 5);
assert(nosh.b == 6);
}
{
Tuple!(short, double) b;
static assert(b.length == 2);
b[1] = 5;
auto a = Tuple!(int, real)(b);
assert(a[0] == 0 && a[1] == 5);
a = Tuple!(int, real)(1, 2);
assert(a[0] == 1 && a[1] == 2);
auto c = Tuple!(int, "a", double, "b")(a);
assert(c[0] == 1 && c[1] == 2);
}
{
Tuple!(int, real) nosh;
nosh[0] = 5;
nosh[1] = 0;
assert(nosh[0] == 5 && nosh[1] == 0);
assert(nosh.to!string == "Tuple!(int, real)(5, 0)", nosh.to!string);
Tuple!(int, int) yessh;
nosh = yessh;
}
{
class A {}
Tuple!(int, shared A) nosh;
nosh[0] = 5;
assert(nosh[0] == 5 && nosh[1] is null);
assert(nosh.to!string == "Tuple!(int, shared(A))(5, shared(A))");
}
{
Tuple!(int, string) t;
t[0] = 10;
t[1] = "str";
assert(t[0] == 10 && t[1] == "str");
assert(t.to!string == `Tuple!(int, string)(10, "str")`, t.to!string);
}
{
Tuple!(int, "a", double, "b") x;
static assert(x.a.offsetof == x[0].offsetof);
static assert(x.b.offsetof == x[1].offsetof);
x.b = 4.5;
x.a = 5;
assert(x[0] == 5 && x[1] == 4.5);
assert(x.a == 5 && x.b == 4.5);
}
// indexing
{
Tuple!(int, real) t;
static assert(is(typeof(t[0]) == int));
static assert(is(typeof(t[1]) == real));
int* p0 = &t[0];
real* p1 = &t[1];
t[0] = 10;
t[1] = -200.0L;
assert(*p0 == t[0]);
assert(*p1 == t[1]);
}
// slicing
{
Tuple!(int, "x", real, "y", double, "z", string) t;
t[0] = 10;
t[1] = 11;
t[2] = 12;
t[3] = "abc";
auto a = t.slice!(0, 3);
assert(a.length == 3);
assert(a.x == t.x);
assert(a.y == t.y);
assert(a.z == t.z);
auto b = t.slice!(2, 4);
assert(b.length == 2);
assert(b.z == t.z);
assert(b[1] == t[3]);
}
// nesting
{
Tuple!(Tuple!(int, real), Tuple!(string, "s")) t;
static assert(is(typeof(t[0]) == Tuple!(int, real)));
static assert(is(typeof(t[1]) == Tuple!(string, "s")));
static assert(is(typeof(t[0][0]) == int));
static assert(is(typeof(t[0][1]) == real));
static assert(is(typeof(t[1].s) == string));
t[0] = tuple(10, 20.0L);
t[1].s = "abc";
assert(t[0][0] == 10);
assert(t[0][1] == 20.0L);
assert(t[1].s == "abc");
}
// non-POD
{
static struct S
{
int count;
this(this) { ++count; }
~this() { --count; }
void opAssign(S rhs) { count = rhs.count; }
}
Tuple!(S, S) ss;
Tuple!(S, S) ssCopy = ss;
assert(ssCopy[0].count == 1);
assert(ssCopy[1].count == 1);
ssCopy[1] = ssCopy[0];
assert(ssCopy[1].count == 2);
}
// https://issues.dlang.org/show_bug.cgi?id=2800
{
static struct R
{
Tuple!(int, int) _front;
@property ref Tuple!(int, int) front() return { return _front; }
@property bool empty() { return _front[0] >= 10; }
void popFront() { ++_front[0]; }
}
foreach (a; R())
{
static assert(is(typeof(a) == Tuple!(int, int)));
assert(0 <= a[0] && a[0] < 10);
assert(a[1] == 0);
}
}
// Construction with compatible elements
{
auto t1 = Tuple!(int, double)(1, 1);
// https://issues.dlang.org/show_bug.cgi?id=8702
auto t8702a = tuple(tuple(1));
auto t8702b = Tuple!(Tuple!(int))(Tuple!(int)(1));
}
// Construction with compatible tuple
{
Tuple!(int, int) x;
x[0] = 10;
x[1] = 20;
Tuple!(int, "a", double, "b") y = x;
assert(y.a == 10);
assert(y.b == 20);
// incompatible
static assert(!__traits(compiles, Tuple!(int, int)(y)));
}
// https://issues.dlang.org/show_bug.cgi?id=6275
{
const int x = 1;
auto t1 = tuple(x);
alias T = Tuple!(const(int));
auto t2 = T(1);
}
// https://issues.dlang.org/show_bug.cgi?id=9431
{
alias T = Tuple!(int[1][]);
auto t = T([[10]]);
}
// https://issues.dlang.org/show_bug.cgi?id=7666
{
auto tup = tuple(1, "2");
assert(tup.reverse == tuple("2", 1));
}
{
Tuple!(int, "x", string, "y") tup = tuple(1, "2");
auto rev = tup.reverse;
assert(rev == tuple("2", 1));
assert(rev.x == 1 && rev.y == "2");
}
{
Tuple!(wchar, dchar, int, "x", string, "y", char, byte, float) tup;
tup = tuple('a', 'b', 3, "4", 'c', cast(byte) 0x0D, 0.00);
auto rev = tup.reverse;
assert(rev == tuple(0.00, cast(byte) 0x0D, 'c', "4", 3, 'b', 'a'));
assert(rev.x == 3 && rev.y == "4");
}
}
@safe unittest
{
// opEquals
{
struct Equ1 { bool opEquals(Equ1) { return true; } }
auto tm1 = tuple(Equ1.init);
const tc1 = tuple(Equ1.init);
static assert( is(typeof(tm1 == tm1)));
static assert(!is(typeof(tm1 == tc1)));
static assert(!is(typeof(tc1 == tm1)));
static assert(!is(typeof(tc1 == tc1)));
struct Equ2 { bool opEquals(const Equ2) const { return true; } }
auto tm2 = tuple(Equ2.init);
const tc2 = tuple(Equ2.init);
static assert( is(typeof(tm2 == tm2)));
static assert( is(typeof(tm2 == tc2)));
static assert( is(typeof(tc2 == tm2)));
static assert( is(typeof(tc2 == tc2)));
// https://issues.dlang.org/show_bug.cgi?id=8686
struct Equ3 { bool opEquals(T)(T) { return true; } }
auto tm3 = tuple(Equ3.init);
const tc3 = tuple(Equ3.init);
static assert( is(typeof(tm3 == tm3)));
static assert( is(typeof(tm3 == tc3)));
static assert(!is(typeof(tc3 == tm3)));
static assert(!is(typeof(tc3 == tc3)));
struct Equ4 { bool opEquals(T)(T) const { return true; } }
auto tm4 = tuple(Equ4.init);
const tc4 = tuple(Equ4.init);
static assert( is(typeof(tm4 == tm4)));
static assert( is(typeof(tm4 == tc4)));
static assert( is(typeof(tc4 == tm4)));
static assert( is(typeof(tc4 == tc4)));
}
// opCmp
{
struct Cmp1 { int opCmp(Cmp1) { return 0; } }
auto tm1 = tuple(Cmp1.init);
const tc1 = tuple(Cmp1.init);
static assert( is(typeof(tm1 < tm1)));
static assert(!is(typeof(tm1 < tc1)));
static assert(!is(typeof(tc1 < tm1)));
static assert(!is(typeof(tc1 < tc1)));
struct Cmp2 { int opCmp(const Cmp2) const { return 0; } }
auto tm2 = tuple(Cmp2.init);
const tc2 = tuple(Cmp2.init);
static assert( is(typeof(tm2 < tm2)));
static assert( is(typeof(tm2 < tc2)));
static assert( is(typeof(tc2 < tm2)));
static assert( is(typeof(tc2 < tc2)));
struct Cmp3 { int opCmp(T)(T) { return 0; } }
auto tm3 = tuple(Cmp3.init);
const tc3 = tuple(Cmp3.init);
static assert( is(typeof(tm3 < tm3)));
static assert( is(typeof(tm3 < tc3)));
static assert(!is(typeof(tc3 < tm3)));
static assert(!is(typeof(tc3 < tc3)));
struct Cmp4 { int opCmp(T)(T) const { return 0; } }
auto tm4 = tuple(Cmp4.init);
const tc4 = tuple(Cmp4.init);
static assert( is(typeof(tm4 < tm4)));
static assert( is(typeof(tm4 < tc4)));
static assert( is(typeof(tc4 < tm4)));
static assert( is(typeof(tc4 < tc4)));
}
// https://issues.dlang.org/show_bug.cgi?id=14890
static void test14890(inout int[] dummy)
{
alias V = Tuple!(int, int);
V mv;
const V cv;
immutable V iv;
inout V wv; // OK <- NG
inout const V wcv; // OK <- NG
static foreach (v1; AliasSeq!(mv, cv, iv, wv, wcv))
static foreach (v2; AliasSeq!(mv, cv, iv, wv, wcv))
{
assert(!(v1 < v2));
}
}
{
int[2] ints = [ 1, 2 ];
Tuple!(int, int) t = ints;
assert(t[0] == 1 && t[1] == 2);
Tuple!(long, uint) t2 = ints;
assert(t2[0] == 1 && t2[1] == 2);
}
}
@safe unittest
{
auto t1 = Tuple!(int, "x", string, "y")(1, "a");
assert(t1.x == 1);
assert(t1.y == "a");
void foo(Tuple!(int, string) t2) {}
foo(t1);
Tuple!(int, int)[] arr;
arr ~= tuple(10, 20); // OK
arr ~= Tuple!(int, "x", int, "y")(10, 20); // NG -> OK
static assert(is(typeof(Tuple!(int, "x", string, "y").tupleof) ==
typeof(Tuple!(int, string ).tupleof)));
}
@safe unittest
{
// https://issues.dlang.org/show_bug.cgi?id=10686
immutable Tuple!(int) t1;
auto r1 = t1[0]; // OK
immutable Tuple!(int, "x") t2;
auto r2 = t2[0]; // error
}
@safe unittest
{
import std.exception : assertCTFEable;
// https://issues.dlang.org/show_bug.cgi?id=10218
assertCTFEable!(
{
auto t = tuple(1);
t = tuple(2); // assignment
});
}
@safe unittest
{
class Foo{}
Tuple!(immutable(Foo)[]) a;
}
@safe unittest
{
//Test non-assignable
static struct S
{
int* p;
}
alias IS = immutable S;
static assert(!isAssignable!IS);
auto s = IS.init;
alias TIS = Tuple!IS;
TIS a = tuple(s);
TIS b = a;
alias TISIS = Tuple!(IS, IS);
TISIS d = tuple(s, s);
IS[2] ss;
TISIS e = TISIS(ss);
}
// https://issues.dlang.org/show_bug.cgi?id=9819
@safe unittest
{
alias T = Tuple!(int, "x", double, "foo");
static assert(T.fieldNames[0] == "x");
static assert(T.fieldNames[1] == "foo");
alias Fields = Tuple!(int, "id", string, float);
static assert(Fields.fieldNames == AliasSeq!("id", "", ""));
}
// https://issues.dlang.org/show_bug.cgi?id=13837
@safe unittest
{
// New behaviour, named arguments.
static assert(is(
typeof(tuple!("x")(1)) == Tuple!(int, "x")));
static assert(is(
typeof(tuple!("x")(1.0)) == Tuple!(double, "x")));
static assert(is(
typeof(tuple!("x")("foo")) == Tuple!(string, "x")));
static assert(is(
typeof(tuple!("x", "y")(1, 2.0)) == Tuple!(int, "x", double, "y")));
auto a = tuple!("a", "b", "c")("1", 2, 3.0f);
static assert(is(typeof(a.a) == string));
static assert(is(typeof(a.b) == int));
static assert(is(typeof(a.c) == float));
// Old behaviour, but with explicit type parameters.
static assert(is(
typeof(tuple!(int, double)(1, 2.0)) == Tuple!(int, double)));
static assert(is(
typeof(tuple!(const int)(1)) == Tuple!(const int)));
static assert(is(
typeof(tuple()) == Tuple!()));
// Nonsensical behaviour
static assert(!__traits(compiles, tuple!(1)(2)));
static assert(!__traits(compiles, tuple!("x")(1, 2)));
static assert(!__traits(compiles, tuple!("x", "y")(1)));
static assert(!__traits(compiles, tuple!("x")()));
static assert(!__traits(compiles, tuple!("x", int)(2)));
}
@safe unittest
{
class C { override size_t toHash() const nothrow @safe { return 0; } }
Tuple!(Rebindable!(const C)) a;
Tuple!(const C) b;
a = b;
}
@nogc @safe unittest
{
alias T = Tuple!(string, "s");
T x;
x = T.init;
}
@safe unittest
{
import std.format : format, FormatException;
import std.exception : assertThrown;
//enum tupStr = tuple(1, 1.0).toString; // toString is *impure*.
//static assert(tupStr == `Tuple!(int, double)(1, 1)`);
}
// https://issues.dlang.org/show_bug.cgi?id=17803, parte uno
@safe unittest
{
auto a = tuple(3, "foo");
assert(__traits(compiles, { a = (a = a); }));
}
// Ditto
@safe unittest
{
Tuple!(int[]) a, b, c;
a = tuple([0, 1, 2]);
c = b = a;
assert(a[0].length == b[0].length && b[0].length == c[0].length);
assert(a[0].ptr == b[0].ptr && b[0].ptr == c[0].ptr);
}
/**
Constructs a $(LREF Tuple) object instantiated and initialized according to
the given arguments.
Params:
Names = An optional list of strings naming each successive field of the `Tuple`
or a list of types that the elements are being casted to.
For a list of names,
each name matches up with the corresponding field given by `Args`.
A name does not have to be provided for every field, but as
the names must proceed in order, it is not possible to skip
one field and name the next after it.
For a list of types,
there must be exactly as many types as parameters.
*/
template tuple(Names...)
{
/**
Params:
args = Values to initialize the `Tuple` with. The `Tuple`'s type will
be inferred from the types of the values given.
Returns:
A new `Tuple` with its type inferred from the arguments given.
*/
auto tuple(Args...)(Args args)
{
static if (Names.length == 0)
{
// No specified names, just infer types from Args...
return Tuple!Args(args);
}
else static if (!is(typeof(Names[0]) : string))
{
// Names[0] isn't a string, must be explicit types.
return Tuple!Names(args);
}
else
{
// Names[0] is a string, so must be specifying names.
static assert(Names.length == Args.length,
"Insufficient number of names given.");
// Interleave(a, b).and(c, d) == (a, c, b, d)
// This is to get the interleaving of types and names for Tuple
// e.g. Tuple!(int, "x", string, "y")
template Interleave(A...)
{
template and(B...) if (B.length == 1)
{
alias and = AliasSeq!(A[0], B[0]);
}
template and(B...) if (B.length != 1)
{
alias and = AliasSeq!(A[0], B[0],
Interleave!(A[1..$]).and!(B[1..$]));
}
}
return Tuple!(Interleave!(Args).and!(Names))(args);
}
}
}
///
@safe unittest
{
auto value = tuple(5, 6.7, "hello");
assert(value[0] == 5);
assert(value[1] == 6.7);
assert(value[2] == "hello");
// Field names can be provided.
auto entry = tuple!("index", "value")(4, "Hello");
assert(entry.index == 4);
assert(entry.value == "Hello");
}
/**
Returns `true` if and only if `T` is an instance of `std.typecons.Tuple`.
Params:
T = The type to check.
Returns:
true if `T` is a `Tuple` type, false otherwise.
*/
enum isTuple(T) = __traits(compiles,
{
void f(Specs...)(Tuple!Specs tup) {}
f(T.init);
} );
///
@safe unittest
{
static assert(isTuple!(Tuple!()));
static assert(isTuple!(Tuple!(int)));
static assert(isTuple!(Tuple!(int, real, string)));
static assert(isTuple!(Tuple!(int, "x", real, "y")));
static assert(isTuple!(Tuple!(int, Tuple!(real), string)));
}
@safe unittest
{
static assert(isTuple!(const Tuple!(int)));
static assert(isTuple!(immutable Tuple!(int)));
static assert(!isTuple!(int));
static assert(!isTuple!(const int));
struct S {}
static assert(!isTuple!(S));
}
// used by both Rebindable and UnqualRef
private mixin template RebindableCommon(T, U, alias This)
if (is(T == class) || is(T == interface) || isAssociativeArray!T)
{
private union
{
T original;
U stripped;
}
void opAssign(T another) pure nothrow @nogc
{
// If `T` defines `opCast` we must infer the safety
static if (hasMember!(T, "opCast"))
{
// This will allow the compiler to infer the safety of `T.opCast!U`
// without generating any runtime cost
if (false) { stripped = cast(U) another; }
}
() @trusted { stripped = cast(U) another; }();
}
void opAssign(typeof(this) another) @trusted pure nothrow @nogc
{
stripped = another.stripped;
}
static if (is(T == const U) && is(T == const shared U))
{
// safely assign immutable to const / const shared
void opAssign(This!(immutable U) another) @trusted pure nothrow @nogc
{
stripped = another.stripped;
}
}
this(T initializer) pure nothrow @nogc
{
// Infer safety from opAssign
opAssign(initializer);
}
@property inout(T) get() @trusted pure nothrow @nogc inout
{
return original;
}
bool opEquals()(auto ref const(typeof(this)) rhs) const
{
// Must forward explicitly because 'stripped' is part of a union.
// The necessary 'toHash' is forwarded to the class via alias this.
return stripped == rhs.stripped;
}
bool opEquals(const(U) rhs) const
{
return stripped == rhs;
}
alias get this;
}
/**
`Rebindable!(T)` is a simple, efficient wrapper that behaves just
like an object of type `T`, except that you can reassign it to
refer to another object. For completeness, `Rebindable!(T)` aliases
itself away to `T` if `T` is a non-const object type.
You may want to use `Rebindable` when you want to have mutable
storage referring to `const` objects, for example an array of
references that must be sorted in place. `Rebindable` does not
break the soundness of D's type system and does not incur any of the
risks usually associated with `cast`.
Params:
T = An object, interface, array slice type, or associative array type.
*/
template Rebindable(T)
if (is(T == class) || is(T == interface) || isDynamicArray!T || isAssociativeArray!T)
{
static if (is(T == const U, U) || is(T == immutable U, U))
{
static if (isDynamicArray!T)
{
import std.range.primitives : ElementEncodingType;
alias Rebindable = const(ElementEncodingType!T)[];
}
else
{
struct Rebindable
{
mixin RebindableCommon!(T, U, Rebindable);
}
}
}
else
{
alias Rebindable = T;
}
}
///Regular `const` object references cannot be reassigned.
@safe unittest
{
class Widget { int x; int y() @safe const { return x; } }
const a = new Widget;
// Fine
a.y();
// error! can't modify const a
// a.x = 5;
// error! can't modify const a
// a = new Widget;
}
/**
However, `Rebindable!(Widget)` does allow reassignment,
while otherwise behaving exactly like a $(D const Widget).
*/
@safe unittest
{
class Widget { int x; int y() const @safe { return x; } }
auto a = Rebindable!(const Widget)(new Widget);
// Fine
a.y();
// error! can't modify const a
// a.x = 5;
// Fine
a = new Widget;
}
// https://issues.dlang.org/show_bug.cgi?id=16054
@safe unittest
{
Rebindable!(immutable Object) r;
static assert(__traits(compiles, r.get()));
static assert(!__traits(compiles, &r.get()));
}
@safe unittest
{
class CustomToHash
{
override size_t toHash() const nothrow @trusted { return 42; }
}
Rebindable!(immutable(CustomToHash)) a = new immutable CustomToHash();
assert(a.toHash() == 42, "Rebindable!A should offer toHash()"
~ " by forwarding to A.toHash().");
}
// https://issues.dlang.org/show_bug.cgi?id=18615
// Rebindable!A should use A.opEqualsa
@system unittest
{
class CustomOpEq
{
int x;
override bool opEquals(Object rhsObj)
{
if (auto rhs = cast(const(CustomOpEq)) rhsObj)
return this.x == rhs.x;
else
return false;
}
}
CustomOpEq a = new CustomOpEq();
CustomOpEq b = new CustomOpEq();
assert(a !is b);
assert(a == b, "a.x == b.x should be true (0 == 0).");
Rebindable!(const(CustomOpEq)) ra = a;
Rebindable!(const(CustomOpEq)) rb = b;
assert(ra !is rb);
assert(ra == rb, "Rebindable should use CustomOpEq's opEquals, not 'is'.");
assert(ra == b, "Rebindable!(someQualifier(A)) should be comparable"
~ " against const(A) via A.opEquals.");
assert(a == rb, "Rebindable!(someQualifier(A)) should be comparable"
~ " against const(A) via A.opEquals.");
b.x = 1;
assert(a != b);
assert(ra != b, "Rebindable!(someQualifier(A)) should be comparable"
~ " against const(A) via A.opEquals.");
assert(a != rb, "Rebindable!(someQualifier(A)) should be comparable"
~ " against const(A) via A.opEquals.");
Rebindable!(const(Object)) o1 = new Object();
Rebindable!(const(Object)) o2 = new Object();
assert(o1 !is o2);
assert(o1 == o1, "When the class doesn't provide its own opEquals,"
~ " Rebindable treats 'a == b' as 'a is b' like Object.opEquals.");
assert(o1 != o2, "When the class doesn't provide its own opEquals,"
~ " Rebindable treats 'a == b' as 'a is b' like Object.opEquals.");
assert(o1 != new Object(), "Rebindable!(const(Object)) should be"
~ " comparable against Object itself and use Object.opEquals.");
}
// https://issues.dlang.org/show_bug.cgi?id=18755
@safe unittest
{
static class Foo
{
auto opCast(T)() @system immutable pure nothrow
{
*(cast(uint*) 0xdeadbeef) = 0xcafebabe;
return T.init;
}
}
static assert(!__traits(compiles, () @safe {
auto r = Rebindable!(immutable Foo)(new Foo);
}));
static assert(__traits(compiles, () @system {
auto r = Rebindable!(immutable Foo)(new Foo);
}));
}
/**
Convenience function for creating a `Rebindable` using automatic type
inference.
Params:
obj = A reference to an object, interface, associative array, or an array slice
to initialize the `Rebindable` with.
Returns:
A newly constructed `Rebindable` initialized with the given reference.
*/
Rebindable!T rebindable(T)(T obj)
if (is(T == class) || is(T == interface) || isDynamicArray!T || isAssociativeArray!T)
{
typeof(return) ret;
ret = obj;
return ret;
}
///
@system unittest
{
class C
{
int payload;
this(int p) { payload = p; }
}
const c = new C(1);
auto c2 = c.rebindable;
assert(c2.payload == 1);
// passing Rebindable to rebindable
c2 = c2.rebindable;
c2 = new C(2);
assert(c2.payload == 2);
const c3 = c2.get;
assert(c3.payload == 2);
}
/**
This function simply returns the `Rebindable` object passed in. It's useful
in generic programming cases when a given object may be either a regular
`class` or a `Rebindable`.
Params:
obj = An instance of Rebindable!T.
Returns:
`obj` without any modification.
*/
Rebindable!T rebindable(T)(Rebindable!T obj)
{
return obj;
}
// TODO: remove me once the rebindable overloads have been joined
///
@system unittest
{
class C
{
int payload;
this(int p) { payload = p; }
}
const c = new C(1);
auto c2 = c.rebindable;
assert(c2.payload == 1);
// passing Rebindable to rebindable
c2 = c2.rebindable;
assert(c2.payload == 1);
}
@system unittest
{
interface CI { int foo() const; }
class C : CI {
int foo() const { return 42; }
@property int bar() const { return 23; }
}
Rebindable!(C) obj0;
static assert(is(typeof(obj0) == C));
Rebindable!(const(C)) obj1;
static assert(is(typeof(obj1.get) == const(C)), typeof(obj1.get).stringof);
static assert(is(typeof(obj1.stripped) == C));
obj1 = new C;
assert(obj1.get !is null);
obj1 = new const(C);
assert(obj1.get !is null);
Rebindable!(immutable(C)) obj2;
static assert(is(typeof(obj2.get) == immutable(C)));
static assert(is(typeof(obj2.stripped) == C));
obj2 = new immutable(C);
assert(obj1.get !is null);
// test opDot
assert(obj2.foo() == 42);
assert(obj2.bar == 23);
interface I { final int foo() const { return 42; } }
Rebindable!(I) obj3;
static assert(is(typeof(obj3) == I));
Rebindable!(const I) obj4;
static assert(is(typeof(obj4.get) == const I));
static assert(is(typeof(obj4.stripped) == I));
static assert(is(typeof(obj4.foo()) == int));
obj4 = new class I {};
Rebindable!(immutable C) obj5i;
Rebindable!(const C) obj5c;
obj5c = obj5c;
obj5c = obj5i;
obj5i = obj5i;
static assert(!__traits(compiles, obj5i = obj5c));
// Test the convenience functions.
auto obj5convenience = rebindable(obj5i);
assert(obj5convenience is obj5i);
auto obj6 = rebindable(new immutable(C));
static assert(is(typeof(obj6) == Rebindable!(immutable C)));
assert(obj6.foo() == 42);
auto obj7 = rebindable(new C);
CI interface1 = obj7;
auto interfaceRebind1 = rebindable(interface1);
assert(interfaceRebind1.foo() == 42);
const interface2 = interface1;
auto interfaceRebind2 = rebindable(interface2);
assert(interfaceRebind2.foo() == 42);
auto arr = [1,2,3,4,5];
const arrConst = arr;
assert(rebindable(arr) == arr);
assert(rebindable(arrConst) == arr);
// https://issues.dlang.org/show_bug.cgi?id=7654
immutable(char[]) s7654;
Rebindable!(typeof(s7654)) r7654 = s7654;
static foreach (T; AliasSeq!(char, wchar, char, int))
{
static assert(is(Rebindable!(immutable(T[])) == immutable(T)[]));
static assert(is(Rebindable!(const(T[])) == const(T)[]));
static assert(is(Rebindable!(T[]) == T[]));
}
// https://issues.dlang.org/show_bug.cgi?id=12046
static assert(!__traits(compiles, Rebindable!(int[1])));
static assert(!__traits(compiles, Rebindable!(const int[1])));
// Pull request 3341
Rebindable!(immutable int[int]) pr3341 = [123:345];
assert(pr3341[123] == 345);
immutable int[int] pr3341_aa = [321:543];
pr3341 = pr3341_aa;
assert(pr3341[321] == 543);
assert(rebindable(pr3341_aa)[321] == 543);
}
/**
Similar to `Rebindable!(T)` but strips all qualifiers from the reference as
opposed to just constness / immutability. Primary intended use case is with
shared (having thread-local reference to shared class data)
Params:
T = A class or interface type.
*/
template UnqualRef(T)
if (is(T == class) || is(T == interface))
{
static if (is(T == immutable U, U)
|| is(T == const shared U, U)
|| is(T == const U, U)
|| is(T == shared U, U))
{
struct UnqualRef
{
mixin RebindableCommon!(T, U, UnqualRef);
}
}
else
{
alias UnqualRef = T;
}
}
///
@system unittest
{
class Data {}
static shared(Data) a;
static UnqualRef!(shared Data) b;
import core.thread;
auto thread = new core.thread.Thread({
a = new shared Data();
b = new shared Data();
});
thread.start();
thread.join();
assert(a !is null);
assert(b is null);
}
@safe unittest
{
class C { }
alias T = UnqualRef!(const shared C);
static assert(is(typeof(T.stripped) == C));
}
/**
Order the provided members to minimize size while preserving alignment.
Alignment is not always optimal for 80-bit reals, nor for structs declared
as align(1).
Params:
E = A list of the types to be aligned, representing fields
of an aggregate such as a `struct` or `class`.
names = The names of the fields that are to be aligned.
Returns:
A string to be mixed in to an aggregate, such as a `struct` or `class`.
*/
string alignForSize(E...)(const char[][] names...)
{
// Sort all of the members by .alignof.
// BUG: Alignment is not always optimal for align(1) structs
// or 80-bit reals or 64-bit primitives on x86.
// TRICK: Use the fact that .alignof is always a power of 2,
// and maximum 16 on extant systems. Thus, we can perform
// a very limited radix sort.
// Contains the members with .alignof = 64,32,16,8,4,2,1
assert(E.length == names.length,
"alignForSize: There should be as many member names as the types");
string[7] declaration = ["", "", "", "", "", "", ""];
foreach (i, T; E)
{
auto a = T.alignof;
auto k = a >= 64? 0 : a >= 32? 1 : a >= 16? 2 : a >= 8? 3 : a >= 4? 4 : a >= 2? 5 : 6;
declaration[k] ~= T.stringof ~ " " ~ names[i] ~ ";\n";
}
auto s = "";
foreach (decl; declaration)
s ~= decl;
return s;
}
///
@safe unittest
{
struct Banner {
mixin(alignForSize!(byte[6], double)(["name", "height"]));
}
}
@safe unittest
{
enum x = alignForSize!(int[], char[3], short, double[5])("x", "y","z", "w");
struct Foo { int x; }
enum y = alignForSize!(ubyte, Foo, double)("x", "y", "z");
enum passNormalX = x == "double[5] w;\nint[] x;\nshort z;\nchar[3] y;\n";
enum passNormalY = y == "double z;\nFoo y;\nubyte x;\n";
enum passAbnormalX = x == "int[] x;\ndouble[5] w;\nshort z;\nchar[3] y;\n";
enum passAbnormalY = y == "Foo y;\ndouble z;\nubyte x;\n";
// ^ blame https://issues.dlang.org/show_bug.cgi?id=231
static assert(passNormalX || passAbnormalX && double.alignof <= (int[]).alignof);
static assert(passNormalY || passAbnormalY && double.alignof <= int.alignof);
}
// https://issues.dlang.org/show_bug.cgi?id=12914
@safe unittest
{
immutable string[] fieldNames = ["x", "y"];
struct S
{
mixin(alignForSize!(byte, int)(fieldNames));
}
}
/**
Defines a value paired with a distinctive "null" state that denotes
the absence of a value. If default constructed, a $(D
Nullable!T) object starts in the null state. Assigning it renders it
non-null. Calling `nullify` can nullify it again.
Practically `Nullable!T` stores a `T` and a `bool`.
*/
struct Nullable(T)
{
private union DontCallDestructorT
{
T payload;
}
private DontCallDestructorT _value = DontCallDestructorT.init;
private bool _isNull = true;
/**
* Constructor initializing `this` with `value`.
*
* Params:
* value = The value to initialize this `Nullable` with.
*/
this(inout T value) inout
{
_value.payload = value;
_isNull = false;
}
static if (is(T == struct) && hasElaborateDestructor!T)
{
~this()
{
if (!_isNull)
{
destroy(_value.payload);
}
}
}
/**
* If they are both null, then they are equal. If one is null and the other
* is not, then they are not equal. If they are both non-null, then they are
* equal if their values are equal.
*/
bool opEquals()(auto ref const(typeof(this)) rhs) const
{
if (_isNull)
return rhs._isNull;
if (rhs._isNull)
return false;
return _value.payload == rhs._value.payload;
}
/// Ditto
bool opEquals(U)(auto ref const(U) rhs) const
if (!is(U : typeof(this)) && is(typeof(this.get == rhs)))
{
return _isNull ? false : rhs == _value.payload;
}
///
@safe unittest
{
Nullable!int empty;
Nullable!int a = 42;
Nullable!int b = 42;
Nullable!int c = 27;
assert(empty == empty);
assert(empty == Nullable!int.init);
assert(empty != a);
assert(empty != b);
assert(empty != c);
assert(a == b);
assert(a != c);
assert(empty != 42);
assert(a == 42);
assert(c != 42);
}
@safe unittest
{
// Test constness
immutable Nullable!int a = 42;
Nullable!int b = 42;
immutable Nullable!int c = 29;
Nullable!int d = 29;
immutable e = 42;
int f = 29;
assert(a == a);
assert(a == b);
assert(a != c);
assert(a != d);
assert(a == e);
assert(a != f);
// Test rvalue
assert(a == const Nullable!int(42));
assert(a != Nullable!int(29));
}
// https://issues.dlang.org/show_bug.cgi?id=17482
@system unittest
{
import std.variant : Variant;
Nullable!Variant a = Variant(12);
assert(a == 12);
Nullable!Variant e;
assert(e != 12);
}
size_t toHash() const @safe nothrow
{
static if (__traits(compiles, .hashOf(_value.payload)))
return _isNull ? 0 : .hashOf(_value.payload);
else
// Workaround for when .hashOf is not both @safe and nothrow.
return _isNull ? 0 : typeid(T).getHash(&_value.payload);
}
/**
* Gives the string `"Nullable.null"` if `isNull` is `true`. Otherwise, the
* result is equivalent to calling $(REF formattedWrite, std,format) on the
* underlying value.
*
* Params:
* writer = A `char` accepting
* $(REF_ALTTEXT output range, isOutputRange, std, range, primitives)
* fmt = A $(REF FormatSpec, std,format) which is used to represent
* the value if this Nullable is not null
* Returns:
* A `string` if `writer` and `fmt` are not set; `void` otherwise.
*/
string toString()
{
import std.array : appender;
auto app = appender!string();
auto spec = singleSpec("%s");
toString(app, spec);
return app.data;
}
/// ditto
string toString() const
{
import std.array : appender;
auto app = appender!string();
auto spec = singleSpec("%s");
toString(app, spec);
return app.data;
}
/// ditto
void toString(W)(ref W writer, scope const ref FormatSpec!char fmt)
if (isOutputRange!(W, char))
{
import std.range.primitives : put;
if (isNull)
put(writer, "Nullable.null");
else
formatValue(writer, _value.payload, fmt);
}
/// ditto
void toString(W)(ref W writer, scope const ref FormatSpec!char fmt) const
if (isOutputRange!(W, char))
{
import std.range.primitives : put;
if (isNull)
put(writer, "Nullable.null");
else
formatValue(writer, _value.payload, fmt);
}
/**
* Check if `this` is in the null state.
*
* Returns:
* true $(B iff) `this` is in the null state, otherwise false.
*/
@property bool isNull() const @safe pure nothrow
{
return _isNull;
}
///
@safe unittest
{
Nullable!int ni;
assert(ni.isNull);
ni = 0;
assert(!ni.isNull);
}
// https://issues.dlang.org/show_bug.cgi?id=14940
@safe unittest
{
import std.array : appender;
import std.format : formattedWrite;
auto app = appender!string();
Nullable!int a = 1;
formattedWrite(app, "%s", a);
assert(app.data == "1");
}
// https://issues.dlang.org/show_bug.cgi?id=19799
@safe unittest
{
import std.format : format;
const Nullable!string a = const(Nullable!string)();
format!"%s"(a);
}
/**
* Forces `this` to the null state.
*/
void nullify()()
{
static if (is(T == class) || is(T == interface))
_value.payload = null;
else
.destroy(_value.payload);
_isNull = true;
}
///
@safe unittest
{
Nullable!int ni = 0;
assert(!ni.isNull);
ni.nullify();
assert(ni.isNull);
}
/**
* Assigns `value` to the internally-held state. If the assignment
* succeeds, `this` becomes non-null.
*
* Params:
* value = A value of type `T` to assign to this `Nullable`.
*/
void opAssign()(T value)
{
import std.algorithm.mutation : moveEmplace, move;
// the lifetime of the value in copy shall be managed by
// this Nullable, so we must avoid calling its destructor.
auto copy = DontCallDestructorT(value);
if (_isNull)
{
// trusted since payload is known to be T.init here.
() @trusted { moveEmplace(copy.payload, _value.payload); }();
}
else
{
move(copy.payload, _value.payload);
}
_isNull = false;
}
/**
* If this `Nullable` wraps a type that already has a null value
* (such as a pointer), then assigning the null value to this
* `Nullable` is no different than assigning any other value of
* type `T`, and the resulting code will look very strange. It
* is strongly recommended that this be avoided by instead using
* the version of `Nullable` that takes an additional `nullValue`
* template argument.
*/
@safe unittest
{
//Passes
Nullable!(int*) npi;
assert(npi.isNull);
//Passes?!
npi = null;
assert(!npi.isNull);
}
/**
* Gets the value if not null. If `this` is in the null state, and the optional
* parameter `fallback` was provided, it will be returned. Without `fallback`,
* calling `get` with a null state is invalid.
*
* When the fallback type is different from the Nullable type, `get(T)` returns
* the common type.
*
* Params:
* fallback = the value to return in case the `Nullable` is null.
*
* Returns:
* The value held internally by this `Nullable`.
*/
@property ref inout(T) get() inout @safe pure nothrow
{
enum message = "Called `get' on null Nullable!" ~ T.stringof ~ ".";
assert(!isNull, message);
return _value.payload;
}
/// ditto
@property inout(T) get()(inout(T) fallback) inout @safe pure nothrow
{
return isNull ? fallback : _value.payload;
}
/// ditto
@property auto get(U)(inout(U) fallback) inout @safe pure nothrow
{
return isNull ? fallback : _value.payload;
}
//@@@DEPRECATED_2.096@@@
deprecated(
"Implicit conversion with `alias Nullable.get this` will be removed after 2.096. Please use `.get` explicitly.")
@system unittest
{
import core.exception : AssertError;
import std.exception : assertThrown, assertNotThrown;
Nullable!int ni;
int i = 42;
//`get` is implicitly called. Will throw
//an AssertError in non-release mode
assertThrown!AssertError(i = ni);
assert(i == 42);
ni = 5;
assertNotThrown!AssertError(i = ni);
assert(i == 5);
}
//@@@DEPRECATED_2.096@@@
deprecated(
"Implicit conversion with `alias Nullable.get this` will be removed after 2.096. Please use `.get` explicitly.")
@property ref inout(T) get_() inout @safe pure nothrow
{
return get;
}
///
@safe pure nothrow unittest
{
int i = 42;
Nullable!int ni;
int x = ni.get(i);
assert(x == i);
ni = 7;
x = ni.get(i);
assert(x == 7);
}
/**
* Implicitly converts to `T`.
* `this` must not be in the null state.
* This feature is deprecated and will be removed after 2.096.
*/
alias get_ this;
}
/// ditto
auto nullable(T)(T t)
{
return Nullable!T(t);
}
///
@safe unittest
{
struct CustomerRecord
{
string name;
string address;
int customerNum;
}
Nullable!CustomerRecord getByName(string name)
{
//A bunch of hairy stuff
return Nullable!CustomerRecord.init;
}
auto queryResult = getByName("Doe, John");
if (!queryResult.isNull)
{
//Process Mr. Doe's customer record
auto address = queryResult.get.address;
auto customerNum = queryResult.get.customerNum;
//Do some things with this customer's info
}
else
{
//Add the customer to the database
}
}
///
@system unittest
{
import std.exception : assertThrown;
auto a = 42.nullable;
assert(!a.isNull);
assert(a.get == 42);
a.nullify();
assert(a.isNull);
assertThrown!Throwable(a.get);
}
//@@@DEPRECATED_2.096@@@
deprecated(
"Implicit conversion with `alias Nullable.get this` will be removed after 2.096. Please use `.get` explicitly.")
@system unittest
{
import std.exception : assertThrown;
Nullable!int a;
assert(a.isNull);
assertThrown!Throwable(a.get);
a = 5;
assert(!a.isNull);
assert(a == 5);
assert(a != 3);
assert(a.get != 3);
a.nullify();
assert(a.isNull);
a = 3;
assert(a == 3);
a *= 6;
assert(a == 18);
a = a;
assert(a == 18);
a.nullify();
assertThrown!Throwable(a += 2);
}
@safe unittest
{
auto k = Nullable!int(74);
assert(k == 74);
k.nullify();
assert(k.isNull);
}
@safe unittest
{
static int f(scope const Nullable!int x) {
return x.isNull ? 42 : x.get;
}
Nullable!int a;
assert(f(a) == 42);
a = 8;
assert(f(a) == 8);
a.nullify();
assert(f(a) == 42);
}
@system unittest
{
import std.exception : assertThrown;
static struct S { int x; }
Nullable!S s;
assert(s.isNull);
s = S(6);
assert(s == S(6));
assert(s != S(0));
assert(s.get != S(0));
s.get.x = 9190;
assert(s.get.x == 9190);
s.nullify();
assertThrown!Throwable(s.get.x = 9441);
}
@safe unittest
{
// Ensure Nullable can be used in pure/nothrow/@safe environment.
function() @safe pure nothrow
{
Nullable!int n;
assert(n.isNull);
n = 4;
assert(!n.isNull);
assert(n == 4);
n.nullify();
assert(n.isNull);
}();
}
@system unittest
{
// Ensure Nullable can be used when the value is not pure/nothrow/@safe
static struct S
{
int x;
this(this) @system {}
}
Nullable!S s;
assert(s.isNull);
s = S(5);
assert(!s.isNull);
assert(s.get.x == 5);
s.nullify();
assert(s.isNull);
}
// https://issues.dlang.org/show_bug.cgi?id=9404
@safe unittest
{
alias N = Nullable!int;
void foo(N a)
{
N b;
b = a; // `N b = a;` works fine
}
N n;
foo(n);
}
@safe unittest
{
//Check nullable immutable is constructable
{
auto a1 = Nullable!(immutable int)();
auto a2 = Nullable!(immutable int)(1);
auto i = a2.get;
}
//Check immutable nullable is constructable
{
auto a1 = immutable (Nullable!int)();
auto a2 = immutable (Nullable!int)(1);
auto i = a2.get;
}
}
@safe unittest
{
alias NInt = Nullable!int;
//Construct tests
{
//from other Nullable null
NInt a1;
NInt b1 = a1;
assert(b1.isNull);
//from other Nullable non-null
NInt a2 = NInt(1);
NInt b2 = a2;
assert(b2 == 1);
//Construct from similar nullable
auto a3 = immutable(NInt)();
NInt b3 = a3;
assert(b3.isNull);
}
//Assign tests
{
//from other Nullable null
NInt a1;
NInt b1;
b1 = a1;
assert(b1.isNull);
//from other Nullable non-null
NInt a2 = NInt(1);
NInt b2;
b2 = a2;
assert(b2 == 1);
//Construct from similar nullable
auto a3 = immutable(NInt)();
NInt b3 = a3;
b3 = a3;
assert(b3.isNull);
}
}
@safe unittest
{
//Check nullable is nicelly embedable in a struct
static struct S1
{
Nullable!int ni;
}
static struct S2 //inspired from 9404
{
Nullable!int ni;
this(S2 other)
{
ni = other.ni;
}
void opAssign(S2 other)
{
ni = other.ni;
}
}
static foreach (S; AliasSeq!(S1, S2))
{{
S a;
S b = a;
S c;
c = a;
}}
}
// https://issues.dlang.org/show_bug.cgi?id=10268
@system unittest
{
import std.json;
JSONValue value = null;
auto na = Nullable!JSONValue(value);
struct S1 { int val; }
struct S2 { int* val; }
struct S3 { immutable int* val; }
{
auto sm = S1(1);
immutable si = immutable S1(1);
auto x1 = Nullable!S1(sm);
auto x2 = immutable Nullable!S1(sm);
auto x3 = Nullable!S1(si);
auto x4 = immutable Nullable!S1(si);
assert(x1.get.val == 1);
assert(x2.get.val == 1);
assert(x3.get.val == 1);
assert(x4.get.val == 1);
}
auto nm = 10;
immutable ni = 10;
{
auto sm = S2(&nm);
immutable si = immutable S2(&ni);
auto x1 = Nullable!S2(sm);
static assert(!__traits(compiles, { auto x2 = immutable Nullable!S2(sm); }));
static assert(!__traits(compiles, { auto x3 = Nullable!S2(si); }));
auto x4 = immutable Nullable!S2(si);
assert(*x1.get.val == 10);
assert(*x4.get.val == 10);
}
{
auto sm = S3(&ni);
immutable si = immutable S3(&ni);
auto x1 = Nullable!S3(sm);
auto x2 = immutable Nullable!S3(sm);
auto x3 = Nullable!S3(si);
auto x4 = immutable Nullable!S3(si);
assert(*x1.get.val == 10);
assert(*x2.get.val == 10);
assert(*x3.get.val == 10);
assert(*x4.get.val == 10);
}
}
// https://issues.dlang.org/show_bug.cgi?id=10357
@safe unittest
{
import std.datetime;
Nullable!SysTime time = SysTime(0);
}
// https://issues.dlang.org/show_bug.cgi?id=10915
@system unittest
{
import std.conv : to;
import std.array;
Appender!string buffer;
Nullable!int ni;
assert(ni.to!string() == "Nullable.null");
assert((cast(const) ni).to!string() == "Nullable.null");
struct Test { string s; }
alias NullableTest = Nullable!Test;
NullableTest nt = Test("test");
// test output range version
assert(nt.to!string() == `Test("test")`);
// test appender version
assert(nt.toString() == `Test("test")`);
// test const version
assert((cast(const) nt).toString() == `const(Test)("test")`);
NullableTest ntn = Test("null");
assert(ntn.to!string() == `Test("null")`);
class TestToString
{
double d;
this (double d)
{
this.d = d;
}
override string toString()
{
return d.to!string();
}
}
Nullable!TestToString ntts = new TestToString(2.5);
assert(ntts.to!string() == "2.5");
}
// https://issues.dlang.org/show_bug.cgi?id=14477
@safe unittest
{
static struct DisabledDefaultConstructor
{
@disable this();
this(int i) { }
}
Nullable!DisabledDefaultConstructor var;
var = DisabledDefaultConstructor(5);
var.nullify;
}
// https://issues.dlang.org/show_bug.cgi?id=17440
@system unittest
{
static interface I { }
static class C : I
{
int canary;
~this()
{
canary = 0x5050DEAD;
}
}
auto c = new C;
c.canary = 0xA71FE;
auto nc = nullable(c);
nc.nullify;
assert(c.canary == 0xA71FE);
I i = c;
auto ni = nullable(i);
ni.nullify;
assert(c.canary == 0xA71FE);
}
// https://issues.dlang.org/show_bug.cgi?id=19037
@safe unittest
{
import std.datetime : SysTime;
struct Test
{
bool b;
nothrow invariant { assert(b == true); }
SysTime _st;
static bool destroyed;
@disable this();
this(bool b) { this.b = b; }
~this() @safe { destroyed = true; }
// mustn't call opAssign on Test.init in Nullable!Test, because the invariant
// will be called before opAssign on the Test.init that is in Nullable
// and Test.init violates its invariant.
void opAssign(Test rhs) @safe { assert(false); }
}
{
Nullable!Test nt;
nt = Test(true);
// destroy value
Test.destroyed = false;
nt.nullify;
assert(Test.destroyed);
Test.destroyed = false;
}
// don't run destructor on T.init in Nullable on scope exit!
assert(!Test.destroyed);
}
// check that the contained type's destructor is called on assignment
@system unittest
{
struct S
{
// can't be static, since we need a specific value's pointer
bool* destroyedRef;
~this()
{
if (this.destroyedRef)
{
*this.destroyedRef = true;
}
}
}
Nullable!S ns;
bool destroyed;
ns = S(&destroyed);
// reset from rvalue destruction in Nullable's opAssign
destroyed = false;
// overwrite Nullable
ns = S(null);
// the original S should be destroyed.
assert(destroyed == true);
}
// check that the contained type's destructor is still called when required
@system unittest
{
bool destructorCalled = false;
struct S
{
bool* destroyed;
~this() { *this.destroyed = true; }
}
{
Nullable!S ns;
}
assert(!destructorCalled);
{
Nullable!S ns = Nullable!S(S(&destructorCalled));
destructorCalled = false; // reset after S was destroyed in the NS constructor
}
assert(destructorCalled);
}
// check that toHash on Nullable is forwarded to the contained type
@system unittest
{
struct S
{
size_t toHash() const @safe pure nothrow { return 5; }
}
Nullable!S s1 = S();
Nullable!S s2 = Nullable!S();
assert(typeid(Nullable!S).getHash(&s1) == 5);
assert(typeid(Nullable!S).getHash(&s2) == 0);
}
/**
Just like `Nullable!T`, except that the null state is defined as a
particular value. For example, $(D Nullable!(uint, uint.max)) is an
`uint` that sets aside the value `uint.max` to denote a null
state. $(D Nullable!(T, nullValue)) is more storage-efficient than $(D
Nullable!T) because it does not need to store an extra `bool`.
Params:
T = The wrapped type for which Nullable provides a null value.
nullValue = The null value which denotes the null state of this
`Nullable`. Must be of type `T`.
*/
struct Nullable(T, T nullValue)
{
private T _value = nullValue;
/**
Constructor initializing `this` with `value`.
Params:
value = The value to initialize this `Nullable` with.
*/
this(T value)
{
_value = value;
}
template toString()
{
import std.format : FormatSpec, formatValue;
// Needs to be a template because of https://issues.dlang.org/show_bug.cgi?id=13737.
void toString()(scope void delegate(const(char)[]) sink, scope const ref FormatSpec!char fmt)
{
if (isNull)
{
sink.formatValue("Nullable.null", fmt);
}
else
{
sink.formatValue(_value, fmt);
}
}
}
/**
Check if `this` is in the null state.
Returns:
true $(B iff) `this` is in the null state, otherwise false.
*/
@property bool isNull() const
{
//Need to use 'is' if T is a nullable type and
//nullValue is null, or it's a compiler error
static if (is(CommonType!(T, typeof(null)) == T) && nullValue is null)
{
return _value is nullValue;
}
//Need to use 'is' if T is a float type
//because NaN != NaN
else static if (__traits(isFloating, T) || __traits(compiles, { static assert(!(nullValue == nullValue)); }))
{
return _value is nullValue;
}
else
{
return _value == nullValue;
}
}
///
@safe unittest
{
Nullable!(int, -1) ni;
//Initialized to "null" state
assert(ni.isNull);
ni = 0;
assert(!ni.isNull);
}
@system unittest
{
assert(typeof(this).init.isNull, typeof(this).stringof ~
".isNull does not work correctly because " ~ T.stringof ~
" has an == operator that is non-reflexive and could not be" ~
" determined before runtime to be non-reflexive!");
}
// https://issues.dlang.org/show_bug.cgi?id=11135
// disable test until https://issues.dlang.org/show_bug.cgi?id=15316 gets fixed
version (none) @system unittest
{
static foreach (T; AliasSeq!(float, double, real))
{{
Nullable!(T, T.init) nf;
//Initialized to "null" state
assert(nf.isNull);
assert(nf is typeof(nf).init);
nf = 0;
assert(!nf.isNull);
nf.nullify();
assert(nf.isNull);
}}
}
/**
Forces `this` to the null state.
*/
void nullify()()
{
_value = nullValue;
}
///
@safe unittest
{
Nullable!(int, -1) ni = 0;
assert(!ni.isNull);
ni = -1;
assert(ni.isNull);
}
/**
Assigns `value` to the internally-held state. If the assignment
succeeds, `this` becomes non-null. No null checks are made. Note
that the assignment may leave `this` in the null state.
Params:
value = A value of type `T` to assign to this `Nullable`.
If it is `nullvalue`, then the internal state of
this `Nullable` will be set to null.
*/
void opAssign()(T value)
{
import std.algorithm.mutation : swap;
swap(value, _value);
}
/**
If this `Nullable` wraps a type that already has a null value
(such as a pointer), and that null value is not given for
`nullValue`, then assigning the null value to this `Nullable`
is no different than assigning any other value of type `T`,
and the resulting code will look very strange. It is strongly
recommended that this be avoided by using `T`'s "built in"
null value for `nullValue`.
*/
@system unittest
{
//Passes
enum nullVal = cast(int*) 0xCAFEBABE;
Nullable!(int*, nullVal) npi;
assert(npi.isNull);
//Passes?!
npi = null;
assert(!npi.isNull);
}
/**
Gets the value. `this` must not be in the null state.
This function is also called for the implicit conversion to `T`.
Preconditions: `isNull` must be `false`.
Returns:
The value held internally by this `Nullable`.
*/
@property ref inout(T) get() inout
{
//@@@6169@@@: We avoid any call that might evaluate nullValue's %s,
//Because it might messup get's purity and safety inference.
enum message = "Called `get' on null Nullable!(" ~ T.stringof ~ ",nullValue).";
assert(!isNull, message);
return _value;
}
///
@system unittest
{
import std.exception : assertThrown, assertNotThrown;
Nullable!(int, -1) ni;
//`get` is implicitly called. Will throw
//an error in non-release mode
assertThrown!Throwable(ni == 0);
ni = 0;
assertNotThrown!Throwable(ni == 0);
}
/**
Implicitly converts to `T`.
`this` must not be in the null state.
*/
alias get this;
}
/// ditto
auto nullable(alias nullValue, T)(T t)
if (is (typeof(nullValue) == T))
{
return Nullable!(T, nullValue)(t);
}
///
@safe unittest
{
Nullable!(size_t, size_t.max) indexOf(string[] haystack, string needle)
{
//Find the needle, returning -1 if not found
return Nullable!(size_t, size_t.max).init;
}
void sendLunchInvite(string name)
{
}
//It's safer than C...
auto coworkers = ["Jane", "Jim", "Marry", "Fred"];
auto pos = indexOf(coworkers, "Bob");
if (!pos.isNull)
{
//Send Bob an invitation to lunch
sendLunchInvite(coworkers[pos]);
}
else
{
//Bob not found; report the error
}
//And there's no overhead
static assert(Nullable!(size_t, size_t.max).sizeof == size_t.sizeof);
}
///
@system unittest
{
import std.exception : assertThrown;
Nullable!(int, int.min) a;
assert(a.isNull);
assertThrown!Throwable(a.get);
a = 5;
assert(!a.isNull);
assert(a == 5);
static assert(a.sizeof == int.sizeof);
}
///
@safe unittest
{
auto a = nullable!(int.min)(8);
assert(a == 8);
a.nullify();
assert(a.isNull);
}
@nogc nothrow pure @safe unittest
{
// https://issues.dlang.org/show_bug.cgi?id=19226
// fully handle non-self-equal nullValue
static struct Fraction
{
int denominator;
bool isNaN() const
{
return denominator == 0;
}
bool opEquals(const Fraction rhs) const
{
return !isNaN && denominator == rhs.denominator;
}
}
alias N = Nullable!(Fraction, Fraction.init);
assert(N.init.isNull);
}
@safe unittest
{
static int f(scope const Nullable!(int, int.min) x) {
return x.isNull ? 42 : x.get;
}
Nullable!(int, int.min) a;
assert(f(a) == 42);
a = 8;
assert(f(a) == 8);
a.nullify();
assert(f(a) == 42);
}
@safe unittest
{
// Ensure Nullable can be used in pure/nothrow/@safe environment.
function() @safe pure nothrow
{
Nullable!(int, int.min) n;
assert(n.isNull);
n = 4;
assert(!n.isNull);
assert(n == 4);
n.nullify();
assert(n.isNull);
}();
}
@system unittest
{
// Ensure Nullable can be used when the value is not pure/nothrow/@system
static struct S
{
int x;
bool opEquals(const S s) const @system { return s.x == x; }
}
Nullable!(S, S(711)) s;
assert(s.isNull);
s = S(5);
assert(!s.isNull);
assert(s.x == 5);
s.nullify();
assert(s.isNull);
}
@safe unittest
{
//Check nullable is nicelly embedable in a struct
static struct S1
{
Nullable!(int, 0) ni;
}
static struct S2 //inspired from 9404
{
Nullable!(int, 0) ni;
this(S2 other)
{
ni = other.ni;
}
void opAssign(S2 other)
{
ni = other.ni;
}
}
static foreach (S; AliasSeq!(S1, S2))
{{
S a;
S b = a;
S c;
c = a;
}}
}
@system unittest
{
import std.conv : to;
// https://issues.dlang.org/show_bug.cgi?id=10915
Nullable!(int, 1) ni = 1;
assert(ni.to!string() == "Nullable.null");
struct Test { string s; }
alias NullableTest = Nullable!(Test, Test("null"));
NullableTest nt = Test("test");
assert(nt.to!string() == `Test("test")`);
NullableTest ntn = Test("null");
assert(ntn.to!string() == "Nullable.null");
class TestToString
{
double d;
this(double d)
{
this.d = d;
}
override string toString()
{
return d.to!string();
}
}
alias NullableTestToString = Nullable!(TestToString, null);
NullableTestToString ntts = new TestToString(2.5);
assert(ntts.to!string() == "2.5");
}
// apply
/**
Unpacks the content of a `Nullable`, performs an operation and packs it again. Does nothing if isNull.
When called on a `Nullable`, `apply` will unpack the value contained in the `Nullable`,
pass it to the function you provide and wrap the result in another `Nullable` (if necessary).
If the `Nullable` is null, `apply` will return null itself.
Params:
t = a `Nullable`
fun = a function operating on the content of the nullable
Returns:
`fun(t.get).nullable` if `!t.isNull`, else `Nullable.init`.
See also:
$(HTTPS en.wikipedia.org/wiki/Monad_(functional_programming)#The_Maybe_monad, The `Maybe` monad)
*/
template apply(alias fun)
{
import std.functional : unaryFun;
auto apply(T)(auto ref T t)
if (isInstanceOf!(Nullable, T) && is(typeof(unaryFun!fun(T.init.get))))
{
alias FunType = typeof(unaryFun!fun(T.init.get));
enum MustWrapReturn = !isInstanceOf!(Nullable, FunType);
static if (MustWrapReturn)
{
alias ReturnType = Nullable!FunType;
}
else
{
alias ReturnType = FunType;
}
if (!t.isNull)
{
static if (MustWrapReturn)
{
return unaryFun!fun(t.get).nullable;
}
else
{
return unaryFun!fun(t.get);
}
}
else
{
return ReturnType.init;
}
}
}
///
nothrow pure @nogc @safe unittest
{
alias toFloat = i => cast(float) i;
Nullable!int sample;
// apply(null) results in a null `Nullable` of the function's return type.
Nullable!float f = sample.apply!toFloat;
assert(sample.isNull && f.isNull);
sample = 3;
// apply(non-null) calls the function and wraps the result in a `Nullable`.
f = sample.apply!toFloat;
assert(!sample.isNull && !f.isNull);
assert(f.get == 3.0f);
}
///
nothrow pure @nogc @safe unittest
{
alias greaterThree = i => (i > 3) ? i.nullable : Nullable!(typeof(i)).init;
Nullable!int sample;
// when the function already returns a `Nullable`, that `Nullable` is not wrapped.
auto result = sample.apply!greaterThree;
assert(sample.isNull && result.isNull);
// The function may decide to return a null `Nullable`.
sample = 3;
result = sample.apply!greaterThree;
assert(!sample.isNull && result.isNull);
// Or it may return a value already wrapped in a `Nullable`.
sample = 4;
result = sample.apply!greaterThree;
assert(!sample.isNull && !result.isNull);
assert(result.get == 4);
}
// test that Nullable.get(default) can merge types
@safe @nogc nothrow pure
unittest
{
Nullable!ubyte sample = Nullable!ubyte();
// Test that get(U) returns the common type of the Nullable type and the parameter type.
assert(sample.get(1000) == 1000);
}
// Workaround for https://issues.dlang.org/show_bug.cgi?id=20670
@safe @nogc nothrow pure
unittest
{
immutable struct S { }
S[] array = Nullable!(S[])().get(S[].init);
}
// regression test for https://issues.dlang.org/show_bug.cgi?id=21199
@safe @nogc nothrow pure
unittest
{
struct S { int i; }
assert(S(5).nullable.apply!"a.i" == 5);
}
/**
Just like `Nullable!T`, except that the object refers to a value
sitting elsewhere in memory. This makes assignments overwrite the
initially assigned value. Internally `NullableRef!T` only stores a
pointer to `T` (i.e., $(D Nullable!T.sizeof == (T*).sizeof)).
*/
struct NullableRef(T)
{
private T* _value;
/**
Constructor binding `this` to `value`.
Params:
value = The value to bind to.
*/
this(T* value) @safe pure nothrow
{
_value = value;
}
template toString()
{
import std.format : FormatSpec, formatValue;
// Needs to be a template because of https://issues.dlang.org/show_bug.cgi?id=13737.
void toString()(scope void delegate(const(char)[]) sink, scope const ref FormatSpec!char fmt)
{
if (isNull)
{
sink.formatValue("Nullable.null", fmt);
}
else
{
sink.formatValue(*_value, fmt);
}
}
}
/**
Binds the internal state to `value`.
Params:
value = A pointer to a value of type `T` to bind this `NullableRef` to.
*/
void bind(T* value) @safe pure nothrow
{
_value = value;
}
///
@safe unittest
{
NullableRef!int nr = new int(42);
assert(nr == 42);
int* n = new int(1);
nr.bind(n);
assert(nr == 1);
}
/**
Returns `true` if and only if `this` is in the null state.
Returns:
true if `this` is in the null state, otherwise false.
*/
@property bool isNull() const @safe pure nothrow
{
return _value is null;
}
///
@safe unittest
{
NullableRef!int nr;
assert(nr.isNull);
int* n = new int(42);
nr.bind(n);
assert(!nr.isNull && nr == 42);
}
/**
Forces `this` to the null state.
*/
void nullify() @safe pure nothrow
{
_value = null;
}
///
@safe unittest
{
NullableRef!int nr = new int(42);
assert(!nr.isNull);
nr.nullify();
assert(nr.isNull);
}
/**
Assigns `value` to the internally-held state.
Params:
value = A value of type `T` to assign to this `NullableRef`.
If the internal state of this `NullableRef` has not
been initialized, an error will be thrown in
non-release mode.
*/
void opAssign()(T value)
if (isAssignable!T) //@@@9416@@@
{
enum message = "Called `opAssign' on null NullableRef!" ~ T.stringof ~ ".";
assert(!isNull, message);
*_value = value;
}
///
@system unittest
{
import std.exception : assertThrown, assertNotThrown;
NullableRef!int nr;
assert(nr.isNull);
assertThrown!Throwable(nr = 42);
nr.bind(new int(0));
assert(!nr.isNull);
assertNotThrown!Throwable(nr = 42);
assert(nr == 42);
}
/**
Gets the value. `this` must not be in the null state.
This function is also called for the implicit conversion to `T`.
*/
@property ref inout(T) get() inout @safe pure nothrow
{
enum message = "Called `get' on null NullableRef!" ~ T.stringof ~ ".";
assert(!isNull, message);
return *_value;
}
///
@system unittest
{
import std.exception : assertThrown, assertNotThrown;
NullableRef!int nr;
//`get` is implicitly called. Will throw
//an error in non-release mode
assertThrown!Throwable(nr == 0);
nr.bind(new int(0));
assertNotThrown!Throwable(nr == 0);
}
/**
Implicitly converts to `T`.
`this` must not be in the null state.
*/
alias get this;
}
/// ditto
auto nullableRef(T)(T* t)
{
return NullableRef!T(t);
}
///
@system unittest
{
import std.exception : assertThrown;
int x = 5, y = 7;
auto a = nullableRef(&x);
assert(!a.isNull);
assert(a == 5);
assert(x == 5);
a = 42;
assert(x == 42);
assert(!a.isNull);
assert(a == 42);
a.nullify();
assert(x == 42);
assert(a.isNull);
assertThrown!Throwable(a.get);
assertThrown!Throwable(a = 71);
a.bind(&y);
assert(a == 7);
y = 135;
assert(a == 135);
}
@system unittest
{
static int f(scope const NullableRef!int x) {
return x.isNull ? 42 : x.get;
}
int x = 5;
auto a = nullableRef(&x);
assert(f(a) == 5);
a.nullify();
assert(f(a) == 42);
}
@safe unittest
{
// Ensure NullableRef can be used in pure/nothrow/@safe environment.
function() @safe pure nothrow
{
auto storage = new int;
*storage = 19902;
NullableRef!int n;
assert(n.isNull);
n.bind(storage);
assert(!n.isNull);
assert(n == 19902);
n = 2294;
assert(n == 2294);
assert(*storage == 2294);
n.nullify();
assert(n.isNull);
}();
}
@system unittest
{
// Ensure NullableRef can be used when the value is not pure/nothrow/@safe
static struct S
{
int x;
this(this) @system {}
bool opEquals(const S s) const @system { return s.x == x; }
}
auto storage = S(5);
NullableRef!S s;
assert(s.isNull);
s.bind(&storage);
assert(!s.isNull);
assert(s.x == 5);
s.nullify();
assert(s.isNull);
}
@safe unittest
{
//Check nullable is nicelly embedable in a struct
static struct S1
{
NullableRef!int ni;
}
static struct S2 //inspired from 9404
{
NullableRef!int ni;
this(S2 other)
{
ni = other.ni;
}
void opAssign(S2 other)
{
ni = other.ni;
}
}
static foreach (S; AliasSeq!(S1, S2))
{{
S a;
S b = a;
S c;
c = a;
}}
}
// https://issues.dlang.org/show_bug.cgi?id=10915
@system unittest
{
import std.conv : to;
NullableRef!int nri;
assert(nri.to!string() == "Nullable.null");
struct Test
{
string s;
}
NullableRef!Test nt = new Test("test");
assert(nt.to!string() == `Test("test")`);
class TestToString
{
double d;
this(double d)
{
this.d = d;
}
override string toString()
{
return d.to!string();
}
}
TestToString tts = new TestToString(2.5);
NullableRef!TestToString ntts = &tts;
assert(ntts.to!string() == "2.5");
}
/**
`BlackHole!Base` is a subclass of `Base` which automatically implements
all abstract member functions in `Base` as do-nothing functions. Each
auto-implemented function just returns the default value of the return type
without doing anything.
The name came from
$(HTTP search.cpan.org/~sburke/Class-_BlackHole-0.04/lib/Class/_BlackHole.pm, Class::_BlackHole)
Perl module by Sean M. Burke.
Params:
Base = A non-final class for `BlackHole` to inherit from.
See_Also:
$(LREF AutoImplement), $(LREF generateEmptyFunction)
*/
alias BlackHole(Base) = AutoImplement!(Base, generateEmptyFunction, isAbstractFunction);
///
@system unittest
{
import std.math : isNaN;
static abstract class C
{
int m_value;
this(int v) { m_value = v; }
int value() @property { return m_value; }
abstract real realValue() @property;
abstract void doSomething();
}
auto c = new BlackHole!C(42);
assert(c.value == 42);
// Returns real.init which is NaN
assert(c.realValue.isNaN);
// Abstract functions are implemented as do-nothing
c.doSomething();
}
@system unittest
{
import std.math : isNaN;
// return default
{
interface I_1 { real test(); }
auto o = new BlackHole!I_1;
assert(o.test().isNaN()); // NaN
}
// doc example
{
static class C
{
int m_value;
this(int v) { m_value = v; }
int value() @property { return m_value; }
abstract real realValue() @property;
abstract void doSomething();
}
auto c = new BlackHole!C(42);
assert(c.value == 42);
assert(c.realValue.isNaN); // NaN
c.doSomething();
}
// https://issues.dlang.org/show_bug.cgi?id=12058
interface Foo
{
inout(Object) foo() inout;
}
BlackHole!Foo o;
}
nothrow pure @nogc @safe unittest
{
static interface I
{
I foo() nothrow pure @nogc @safe return scope;
}
scope cb = new BlackHole!I();
cb.foo();
}
/**
`WhiteHole!Base` is a subclass of `Base` which automatically implements
all abstract member functions as functions that always fail. These functions
simply throw an `Error` and never return. `Whitehole` is useful for
trapping the use of class member functions that haven't been implemented.
The name came from
$(HTTP search.cpan.org/~mschwern/Class-_WhiteHole-0.04/lib/Class/_WhiteHole.pm, Class::_WhiteHole)
Perl module by Michael G Schwern.
Params:
Base = A non-final class for `WhiteHole` to inherit from.
See_Also:
$(LREF AutoImplement), $(LREF generateAssertTrap)
*/
alias WhiteHole(Base) = AutoImplement!(Base, generateAssertTrap, isAbstractFunction);
///
@system unittest
{
import std.exception : assertThrown;
static class C
{
abstract void notYetImplemented();
}
auto c = new WhiteHole!C;
assertThrown!NotImplementedError(c.notYetImplemented()); // throws an Error
}
// https://issues.dlang.org/show_bug.cgi?id=20232
nothrow pure @safe unittest
{
static interface I
{
I foo() nothrow pure @safe return scope;
}
if (0) // Just checking attribute interference
{
scope cw = new WhiteHole!I();
cw.foo();
}
}
// / ditto
class NotImplementedError : Error
{
this(string method) nothrow pure @safe
{
super(method ~ " is not implemented");
}
}
@system unittest
{
import std.exception : assertThrown;
// nothrow
{
interface I_1
{
void foo();
void bar() nothrow;
}
auto o = new WhiteHole!I_1;
assertThrown!NotImplementedError(o.foo());
assertThrown!NotImplementedError(o.bar());
}
// doc example
{
static class C
{
abstract void notYetImplemented();
}
auto c = new WhiteHole!C;
try
{
c.notYetImplemented();
assert(0);
}
catch (Error e) {}
}
}
/**
`AutoImplement` automatically implements (by default) all abstract member
functions in the class or interface `Base` in specified way.
The second version of `AutoImplement` automatically implements
`Interface`, while deriving from `BaseClass`.
Params:
how = template which specifies _how functions will be implemented/overridden.
Two arguments are passed to `how`: the type `Base` and an alias
to an implemented function. Then `how` must return an implemented
function body as a string.
The generated function body can use these keywords:
$(UL
$(LI `a0`, `a1`, …: arguments passed to the function;)
$(LI `args`: a tuple of the arguments;)
$(LI `self`: an alias to the function itself;)
$(LI `parent`: an alias to the overridden function (if any).)
)
You may want to use templated property functions (instead of Implicit
Template Properties) to generate complex functions:
--------------------
// Prints log messages for each call to overridden functions.
string generateLogger(C, alias fun)() @property
{
import std.traits;
enum qname = C.stringof ~ "." ~ __traits(identifier, fun);
string stmt;
stmt ~= q{ struct Importer { import std.stdio; } };
stmt ~= `Importer.writeln("Log: ` ~ qname ~ `(", args, ")");`;
static if (!__traits(isAbstractFunction, fun))
{
static if (is(ReturnType!fun == void))
stmt ~= q{ parent(args); };
else
stmt ~= q{
auto r = parent(args);
Importer.writeln("--> ", r);
return r;
};
}
return stmt;
}
--------------------
what = template which determines _what functions should be
implemented/overridden.
An argument is passed to `what`: an alias to a non-final member
function in `Base`. Then `what` must return a boolean value.
Return `true` to indicate that the passed function should be
implemented/overridden.
--------------------
// Sees if fun returns something.
enum bool hasValue(alias fun) = !is(ReturnType!(fun) == void);
--------------------
Note:
Generated code is inserted in the scope of `std.typecons` module. Thus,
any useful functions outside `std.typecons` cannot be used in the generated
code. To workaround this problem, you may `import` necessary things in a
local struct, as done in the `generateLogger()` template in the above
example.
BUGS:
$(UL
$(LI Variadic arguments to constructors are not forwarded to super.)
$(LI Deep interface inheritance causes compile error with messages like
"Error: function std.typecons._AutoImplement!(Foo)._AutoImplement.bar
does not override any function". [$(BUGZILLA 2525)] )
$(LI The `parent` keyword is actually a delegate to the super class'
corresponding member function. [$(BUGZILLA 2540)] )
$(LI Using alias template parameter in `how` and/or `what` may cause
strange compile error. Use template tuple parameter instead to workaround
this problem. [$(BUGZILLA 4217)] )
)
*/
class AutoImplement(Base, alias how, alias what = isAbstractFunction) : Base
if (!is(how == class))
{
private alias autoImplement_helper_ =
AutoImplement_Helper!("autoImplement_helper_", "Base", Base, typeof(this), how, what);
mixin(autoImplement_helper_.code);
}
/// ditto
class AutoImplement(
Interface, BaseClass, alias how,
alias what = isAbstractFunction) : BaseClass, Interface
if (is(Interface == interface) && is(BaseClass == class))
{
private alias autoImplement_helper_ = AutoImplement_Helper!(
"autoImplement_helper_", "Interface", Interface, typeof(this), how, what);
mixin(autoImplement_helper_.code);
}
///
@system unittest
{
interface PackageSupplier
{
int foo();
int bar();
}
static abstract class AbstractFallbackPackageSupplier : PackageSupplier
{
protected PackageSupplier default_, fallback;
this(PackageSupplier default_, PackageSupplier fallback)
{
this.default_ = default_;
this.fallback = fallback;
}
abstract int foo();
abstract int bar();
}
template fallback(T, alias func)
{
import std.format : format;
// for all implemented methods:
// - try default first
// - only on a failure run & return fallback
enum fallback = q{
scope (failure) return fallback.%1$s(args);
return default_.%1$s(args);
}.format(__traits(identifier, func));
}
// combines two classes and use the second one as fallback
alias FallbackPackageSupplier = AutoImplement!(AbstractFallbackPackageSupplier, fallback);
class FailingPackageSupplier : PackageSupplier
{
int foo(){ throw new Exception("failure"); }
int bar(){ return 2;}
}
class BackupPackageSupplier : PackageSupplier
{
int foo(){ return -1; }
int bar(){ return -1;}
}
auto registry = new FallbackPackageSupplier(new FailingPackageSupplier(), new BackupPackageSupplier());
assert(registry.foo() == -1);
assert(registry.bar() == 2);
}
/*
* Code-generating stuffs are encupsulated in this helper template so that
* namespace pollution, which can cause name confliction with Base's public
* members, should be minimized.
*/
private template AutoImplement_Helper(string myName, string baseName,
Base, Self, alias generateMethodBody, alias cherrypickMethod)
{
private static:
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
// Internal stuffs
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
// Returns function overload sets in the class C, filtered with pred.
template enumerateOverloads(C, alias pred)
{
template Impl(names...)
{
import std.meta : Filter;
static if (names.length > 0)
{
alias methods = Filter!(pred, MemberFunctionsTuple!(C, names[0]));
alias next = Impl!(names[1 .. $]);
static if (methods.length > 0)
alias Impl = AliasSeq!(OverloadSet!(names[0], methods), next);
else
alias Impl = next;
}
else
alias Impl = AliasSeq!();
}
alias enumerateOverloads = Impl!(__traits(allMembers, C));
}
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
// Target functions
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
// Add a non-final check to the cherrypickMethod.
enum bool canonicalPicker(fun.../+[https://issues.dlang.org/show_bug.cgi?id=4217]+/) =
!__traits(isFinalFunction, fun[0]) && cherrypickMethod!(fun);
/*
* A tuple of overload sets, each item of which consists of functions to be
* implemented by the generated code.
*/
alias targetOverloadSets = enumerateOverloads!(Base, canonicalPicker);
/*
* Super class of this AutoImplement instance
*/
alias Super = BaseTypeTuple!(Self)[0];
static assert(is(Super == class));
static assert(is(Base == interface) || is(Super == Base));
/*
* A tuple of the super class' constructors. Used for forwarding
* constructor calls.
*/
static if (__traits(hasMember, Super, "__ctor"))
alias ctorOverloadSet = OverloadSet!("__ctor", __traits(getOverloads, Super, "__ctor"));
else
alias ctorOverloadSet = OverloadSet!("__ctor"); // empty
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
// Type information
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
/*
* The generated code will be mixed into AutoImplement, which will be
* instantiated in this module's scope. Thus, any user-defined types are
* out of scope and cannot be used directly (i.e. by their names).
*
* We will use FuncInfo instances for accessing return types and parameter
* types of the implemented functions. The instances will be populated to
* the AutoImplement's scope in a certain way; see the populate() below.
*/
// Returns the preferred identifier for the FuncInfo instance for the i-th
// overloaded function with the name.
template INTERNAL_FUNCINFO_ID(string name, size_t i)
{
import std.format : format;
enum string INTERNAL_FUNCINFO_ID = format("F_%s_%s", name, i);
}
/*
* Insert FuncInfo instances about all the target functions here. This
* enables the generated code to access type information via, for example,
* "autoImplement_helper_.F_foo_1".
*/
template populate(overloads...)
{
static if (overloads.length > 0)
{
mixin populate!(overloads[0].name, overloads[0].contents);
mixin populate!(overloads[1 .. $]);
}
}
template populate(string name, methods...)
{
static if (methods.length > 0)
{
mixin populate!(name, methods[0 .. $ - 1]);
//
alias target = methods[$ - 1];
enum ith = methods.length - 1;
mixin("alias " ~ INTERNAL_FUNCINFO_ID!(name, ith) ~ " = FuncInfo!target;");
}
}
public mixin populate!(targetOverloadSets);
public mixin populate!( ctorOverloadSet );
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
// Code-generating policies
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
/* Common policy configurations for generating constructors and methods. */
template CommonGeneratingPolicy()
{
// base class identifier which generated code should use
enum string BASE_CLASS_ID = baseName;
// FuncInfo instance identifier which generated code should use
template FUNCINFO_ID(string name, size_t i)
{
enum string FUNCINFO_ID =
myName ~ "." ~ INTERNAL_FUNCINFO_ID!(name, i);
}
}
/* Policy configurations for generating constructors. */
template ConstructorGeneratingPolicy()
{
mixin CommonGeneratingPolicy;
/* Generates constructor body. Just forward to the base class' one. */
string generateFunctionBody(ctor.../+[https://issues.dlang.org/show_bug.cgi?id=4217]+/)() @property
{
enum varstyle = variadicFunctionStyle!(typeof(&ctor[0]));
static if (varstyle & (Variadic.c | Variadic.d))
{
// the argptr-forwarding problem
//pragma(msg, "Warning: AutoImplement!(", Base, ") ",
// "ignored variadic arguments to the constructor ",
// FunctionTypeOf!(typeof(&ctor[0])) );
}
return "super(args);";
}
}
/* Policy configurations for genearting target methods. */
template MethodGeneratingPolicy()
{
mixin CommonGeneratingPolicy;
/* Geneartes method body. */
string generateFunctionBody(func.../+[https://issues.dlang.org/show_bug.cgi?id=4217]+/)() @property
{
return generateMethodBody!(Base, func); // given
}
}
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
// Generated code
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
alias ConstructorGenerator = MemberFunctionGenerator!(ConstructorGeneratingPolicy!());
alias MethodGenerator = MemberFunctionGenerator!(MethodGeneratingPolicy!());
public enum string code =
ConstructorGenerator.generateCode!( ctorOverloadSet ) ~ "\n" ~
MethodGenerator.generateCode!(targetOverloadSets);
debug (SHOW_GENERATED_CODE)
{
pragma(msg, "-------------------- < ", Base, " >");
pragma(msg, code);
pragma(msg, "--------------------");
}
}
//debug = SHOW_GENERATED_CODE;
@system unittest
{
import core.vararg;
// no function to implement
{
interface I_1 {}
auto o = new BlackHole!I_1;
}
// parameters
{
interface I_3 { void test(int, in int, out int, ref int, lazy int); }
auto o = new BlackHole!I_3;
}
// use of user-defined type
{
struct S {}
interface I_4 { S test(); }
auto o = new BlackHole!I_4;
}
// overloads
{
interface I_5
{
void test(string);
real test(real);
int test();
}
auto o = new BlackHole!I_5;
}
// constructor forwarding
{
static class C_6
{
this(int n) { assert(n == 42); }
this(string s) { assert(s == "Deeee"); }
this(...) {}
}
auto o1 = new BlackHole!C_6(42);
auto o2 = new BlackHole!C_6("Deeee");
auto o3 = new BlackHole!C_6(1, 2, 3, 4);
}
// attributes
{
interface I_7
{
ref int test_ref();
int test_pure() pure;
int test_nothrow() nothrow;
int test_property() @property;
int test_safe() @safe;
int test_trusted() @trusted;
int test_system() @system;
int test_pure_nothrow() pure nothrow;
}
auto o = new BlackHole!I_7;
}
// storage classes
{
interface I_8
{
void test_const() const;
void test_immutable() immutable;
void test_shared() shared;
void test_shared_const() shared const;
}
auto o = new BlackHole!I_8;
}
// use baseclass
{
static class C_9
{
private string foo_;
this(string s) {
foo_ = s;
}
protected string boilerplate() @property
{
return "Boilerplate stuff.";
}
public string foo() @property
{
return foo_;
}
}
interface I_10
{
string testMethod(size_t);
}
static string generateTestMethod(C, alias fun)() @property
{
return "return this.boilerplate[0 .. a0];";
}
auto o = new AutoImplement!(I_10, C_9, generateTestMethod)("Testing");
assert(o.testMethod(11) == "Boilerplate");
assert(o.foo == "Testing");
}
/+ // deep inheritance
{
// https://issues.dlang.org/show_bug.cgi?id=2525
// https://issues.dlang.org/show_bug.cgi?id=3525
// NOTE: [r494] func.c(504-571) FuncDeclaration::semantic()
interface I { void foo(); }
interface J : I {}
interface K : J {}
static abstract class C_9 : K {}
auto o = new BlackHole!C_9;
}+/
}
// https://issues.dlang.org/show_bug.cgi?id=17177
// AutoImplement fails on function overload sets with
// "cannot infer type from overloaded function symbol"
@system unittest
{
static class Issue17177
{
private string n_;
public {
Issue17177 overloaded(string n)
{
this.n_ = n;
return this;
}
string overloaded()
{
return this.n_;
}
}
}
static string how(C, alias fun)()
{
static if (!is(ReturnType!fun == void))
{
return q{
return parent(args);
};
}
else
{
return q{
parent(args);
};
}
}
import std.meta : templateNot;
alias Implementation = AutoImplement!(Issue17177, how, templateNot!isFinalFunction);
}
version (StdUnittest)
{
// https://issues.dlang.org/show_bug.cgi?id=10647
// Add prefix "issue10647_" as a workaround for
// https://issues.dlang.org/show_bug.cgi?id=1238
private string issue10647_generateDoNothing(C, alias fun)() @property
{
string stmt;
static if (is(ReturnType!fun == void))
stmt ~= "";
else
{
string returnType = ReturnType!fun.stringof;
stmt ~= "return "~returnType~".init;";
}
return stmt;
}
private template issue10647_isAlwaysTrue(alias fun)
{
enum issue10647_isAlwaysTrue = true;
}
// Do nothing template
private template issue10647_DoNothing(Base)
{
alias issue10647_DoNothing = AutoImplement!(Base, issue10647_generateDoNothing, issue10647_isAlwaysTrue);
}
// A class to be overridden
private class issue10647_Foo{
void bar(int a) { }
}
}
@system unittest
{
auto foo = new issue10647_DoNothing!issue10647_Foo();
foo.bar(13);
}
/*
Used by MemberFunctionGenerator.
*/
package template OverloadSet(string nam, T...)
{
enum string name = nam;
alias contents = T;
}
/*
Used by MemberFunctionGenerator.
*/
package template FuncInfo(alias func)
if (is(typeof(&func)))
{
alias RT = ReturnType!(typeof(&func));
alias PT = Parameters!(typeof(&func));
}
package template FuncInfo(Func)
{
alias RT = ReturnType!Func;
alias PT = Parameters!Func;
}
/*
General-purpose member function generator.
--------------------
template GeneratingPolicy()
{
// [optional] the name of the class where functions are derived
enum string BASE_CLASS_ID;
// [optional] define this if you have only function types
enum bool WITHOUT_SYMBOL;
// [optional] Returns preferred identifier for i-th parameter.
template PARAMETER_VARIABLE_ID(size_t i);
// Returns the identifier of the FuncInfo instance for the i-th overload
// of the specified name. The identifier must be accessible in the scope
// where generated code is mixed.
template FUNCINFO_ID(string name, size_t i);
// Returns implemented function body as a string. When WITHOUT_SYMBOL is
// defined, the latter is used.
template generateFunctionBody(alias func);
template generateFunctionBody(string name, FuncType);
}
--------------------
*/
package template MemberFunctionGenerator(alias Policy)
{
private static:
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
// Internal stuffs
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
import std.format;
alias format = std.format.format;
enum CONSTRUCTOR_NAME = "__ctor";
// true if functions are derived from a base class
enum WITH_BASE_CLASS = __traits(hasMember, Policy, "BASE_CLASS_ID");
// true if functions are specified as types, not symbols
enum WITHOUT_SYMBOL = __traits(hasMember, Policy, "WITHOUT_SYMBOL");
// preferred identifier for i-th parameter variable
static if (__traits(hasMember, Policy, "PARAMETER_VARIABLE_ID"))
{
alias PARAMETER_VARIABLE_ID = Policy.PARAMETER_VARIABLE_ID;
}
else
{
enum string PARAMETER_VARIABLE_ID(size_t i) = format("a%s", i);
// default: a0, a1, ...
}
// Returns a tuple consisting of 0,1,2,...,n-1. For static foreach.
template CountUp(size_t n)
{
static if (n > 0)
alias CountUp = AliasSeq!(CountUp!(n - 1), n - 1);
else
alias CountUp = AliasSeq!();
}
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
// Code generator
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
/*
* Runs through all the target overload sets and generates D code which
* implements all the functions in the overload sets.
*/
public string generateCode(overloads...)() @property
{
string code = "";
// run through all the overload sets
foreach (i_; CountUp!(0 + overloads.length)) // workaround
{
enum i = 0 + i_; // workaround
alias oset = overloads[i];
code ~= generateCodeForOverloadSet!(oset);
static if (WITH_BASE_CLASS && oset.name != CONSTRUCTOR_NAME)
{
// The generated function declarations may hide existing ones
// in the base class (cf. HiddenFuncError), so we put an alias
// declaration here to reveal possible hidden functions.
code ~= format("alias %s = %s.%s;\n",
oset.name,
// super: https://issues.dlang.org/show_bug.cgi?id=2540
Policy.BASE_CLASS_ID,
oset.name);
}
}
return code;
}
// handle each overload set
private string generateCodeForOverloadSet(alias oset)() @property
{
string code = "";
foreach (i_; CountUp!(0 + oset.contents.length)) // workaround
{
enum i = 0 + i_; // workaround
code ~= generateFunction!(
Policy.FUNCINFO_ID!(oset.name, i), oset.name,
oset.contents[i]) ~ "\n";
}
return code;
}
/*
* Returns D code which implements the function func. This function
* actually generates only the declarator part; the function body part is
* generated by the functionGenerator() policy.
*/
public string generateFunction(
string myFuncInfo, string name, func... )() @property
{
import std.format : format;
enum isCtor = (name == CONSTRUCTOR_NAME);
string code; // the result
auto paramsRes = generateParameters!(myFuncInfo, func)();
code ~= paramsRes.imports;
/*** Function Declarator ***/
{
alias Func = FunctionTypeOf!(func);
alias FA = FunctionAttribute;
enum atts = functionAttributes!(func);
enum realName = isCtor ? "this" : name;
// FIXME?? Make it so that these aren't CTFE funcs any more, since
// Format is deprecated, and format works at compile time?
/* Made them CTFE funcs just for the sake of Format!(...) */
// return type with optional "ref"
static string make_returnType()
{
string rtype = "";
if (!isCtor)
{
if (atts & FA.ref_) rtype ~= "ref ";
rtype ~= myFuncInfo ~ ".RT";
}
return rtype;
}
enum returnType = make_returnType();
// function attributes attached after declaration
static string make_postAtts()
{
string poatts = "";
if (atts & FA.pure_ ) poatts ~= " pure";
if (atts & FA.nothrow_) poatts ~= " nothrow";
if (atts & FA.property) poatts ~= " @property";
if (atts & FA.safe ) poatts ~= " @safe";
if (atts & FA.trusted ) poatts ~= " @trusted";
if (atts & FA.scope_ ) poatts ~= " scope";
if (atts & FA.return_ ) poatts ~= " return";
return poatts;
}
enum postAtts = make_postAtts();
// function storage class
static string make_storageClass()
{
string postc = "";
if (is(Func == shared)) postc ~= " shared";
if (is(Func == const)) postc ~= " const";
if (is(Func == inout)) postc ~= " inout";
if (is(Func == immutable)) postc ~= " immutable";
return postc;
}
enum storageClass = make_storageClass();
//
if (__traits(isVirtualMethod, func))
code ~= "override ";
code ~= format("extern(%s) %s %s(%s) %s %s\n",
functionLinkage!(func),
returnType,
realName,
paramsRes.params,
postAtts, storageClass );
}
/*** Function Body ***/
code ~= "{\n";
{
enum nparams = Parameters!(func).length;
/* Declare keywords: args, self and parent. */
string preamble;
preamble ~= "alias args = AliasSeq!(" ~ enumerateParameters!(nparams) ~ ");\n";
if (!isCtor)
{
preamble ~= "alias self = " ~ name ~ ";\n";
if (WITH_BASE_CLASS && !__traits(isAbstractFunction, func))
preamble ~= `alias parent = __traits(getMember, super, "` ~ name ~ `");`;
}
// Function body
static if (WITHOUT_SYMBOL)
enum fbody = Policy.generateFunctionBody!(name, func);
else
enum fbody = Policy.generateFunctionBody!(func);
code ~= preamble;
code ~= fbody;
}
code ~= "}";
return code;
}
/*
* Returns D code which declares function parameters,
* and optionally any imports (e.g. core.vararg)
* "ref int a0, real a1, ..."
*/
static struct GenParams { string imports, params; }
private GenParams generateParameters(string myFuncInfo, func...)()
{
alias STC = ParameterStorageClass;
alias stcs = ParameterStorageClassTuple!(func);
enum nparams = stcs.length;
string imports = ""; // any imports required
string params = ""; // parameters
foreach (i, stc; stcs)
{
if (i > 0) params ~= ", ";
// Parameter storage classes.
if (stc & STC.scope_) params ~= "scope ";
if (stc & STC.in_) params ~= "in ";
if (stc & STC.out_ ) params ~= "out ";
if (stc & STC.ref_ ) params ~= "ref ";
if (stc & STC.lazy_ ) params ~= "lazy ";
// Take parameter type from the FuncInfo.
params ~= format("%s.PT[%s]", myFuncInfo, i);
// Declare a parameter variable.
params ~= " " ~ PARAMETER_VARIABLE_ID!(i);
}
// Add some ellipsis part if needed.
auto style = variadicFunctionStyle!(func);
final switch (style)
{
case Variadic.no:
break;
case Variadic.c, Variadic.d:
imports ~= "import core.vararg;\n";
// (...) or (a, b, ...)
params ~= (nparams == 0) ? "..." : ", ...";
break;
case Variadic.typesafe:
params ~= " ...";
break;
}
return typeof(return)(imports, params);
}
// Returns D code which enumerates n parameter variables using comma as the
// separator. "a0, a1, a2, a3"
private string enumerateParameters(size_t n)() @property
{
string params = "";
foreach (i_; CountUp!(n))
{
enum i = 0 + i_; // workaround
if (i > 0) params ~= ", ";
params ~= PARAMETER_VARIABLE_ID!(i);
}
return params;
}
}
/**
Predefined how-policies for `AutoImplement`. These templates are also used by
`BlackHole` and `WhiteHole`, respectively.
*/
template generateEmptyFunction(C, func.../+[https://issues.dlang.org/show_bug.cgi?id=4217]+/)
{
static if (is(ReturnType!(func) == void))
enum string generateEmptyFunction = q{
};
else static if (functionAttributes!(func) & FunctionAttribute.ref_)
enum string generateEmptyFunction = q{
static typeof(return) dummy;
return dummy;
};
else
enum string generateEmptyFunction = q{
return typeof(return).init;
};
}
///
@system unittest
{
alias BlackHole(Base) = AutoImplement!(Base, generateEmptyFunction);
interface I
{
int foo();
string bar();
}
auto i = new BlackHole!I();
// generateEmptyFunction returns the default value of the return type without doing anything
assert(i.foo == 0);
assert(i.bar is null);
}
/// ditto
template generateAssertTrap(C, func...)
{
enum string generateAssertTrap =
`throw new NotImplementedError("` ~ C.stringof ~ "."
~ __traits(identifier, func) ~ `");`;
}
///
@system unittest
{
import std.exception : assertThrown;
alias WhiteHole(Base) = AutoImplement!(Base, generateAssertTrap);
interface I
{
int foo();
string bar();
}
auto i = new WhiteHole!I();
// generateAssertTrap throws an exception for every unimplemented function of the interface
assertThrown!NotImplementedError(i.foo);
assertThrown!NotImplementedError(i.bar);
}
private
{
pragma(mangle, "_d_toObject")
extern(C) pure nothrow Object typecons_d_toObject(void* p);
}
/*
* Avoids opCast operator overloading.
*/
private template dynamicCast(T)
if (is(T == class) || is(T == interface))
{
@trusted
T dynamicCast(S)(inout S source)
if (is(S == class) || is(S == interface))
{
static if (is(Unqual!S : Unqual!T))
{
import std.traits : QualifierOf;
alias Qual = QualifierOf!S; // SharedOf or MutableOf
alias TmpT = Qual!(Unqual!T);
inout(TmpT) tmp = source; // bypass opCast by implicit conversion
return *cast(T*)(&tmp); // + variable pointer cast + dereference
}
else
{
return cast(T) typecons_d_toObject(*cast(void**)(&source));
}
}
}
@system unittest
{
class C { @disable void opCast(T)(); }
auto c = new C;
static assert(!__traits(compiles, cast(Object) c));
auto o = dynamicCast!Object(c);
assert(c is o);
interface I { @disable void opCast(T)(); Object instance(); }
interface J { @disable void opCast(T)(); Object instance(); }
class D : I, J { Object instance() { return this; } }
I i = new D();
static assert(!__traits(compiles, cast(J) i));
J j = dynamicCast!J(i);
assert(i.instance() is j.instance());
}
/**
Supports structural based typesafe conversion.
If `Source` has structural conformance with the `interface` `Targets`,
wrap creates an internal wrapper class which inherits `Targets` and
wraps the `src` object, then returns it.
`unwrap` can be used to extract objects which have been wrapped by `wrap`.
*/
template wrap(Targets...)
if (Targets.length >= 1 && allSatisfy!(isMutable, Targets))
{
import std.meta : staticMap;
// strict upcast
auto wrap(Source)(inout Source src) @trusted pure nothrow
if (Targets.length == 1 && is(Source : Targets[0]))
{
alias T = Select!(is(Source == shared), shared Targets[0], Targets[0]);
return dynamicCast!(inout T)(src);
}
// structural upcast
template wrap(Source)
if (!allSatisfy!(Bind!(isImplicitlyConvertible, Source), Targets))
{
auto wrap(inout Source src)
{
static assert(hasRequireMethods!(),
"Source "~Source.stringof~
" does not have structural conformance to "~
Targets.stringof);
alias T = Select!(is(Source == shared), shared Impl, Impl);
return new inout T(src);
}
template FuncInfo(string s, F)
{
enum name = s;
alias type = F;
}
// https://issues.dlang.org/show_bug.cgi?id=12064: Remove NVI members
template OnlyVirtual(members...)
{
enum notFinal(alias T) = !__traits(isFinalFunction, T);
import std.meta : Filter;
alias OnlyVirtual = Filter!(notFinal, members);
}
// Concat all Targets function members into one tuple
template Concat(size_t i = 0)
{
static if (i >= Targets.length)
alias Concat = AliasSeq!();
else
{
alias Concat = AliasSeq!(OnlyVirtual!(GetOverloadedMethods!(Targets[i]), Concat!(i + 1)));
}
}
// Remove duplicated functions based on the identifier name and function type covariance
template Uniq(members...)
{
static if (members.length == 0)
alias Uniq = AliasSeq!();
else
{
alias func = members[0];
enum name = __traits(identifier, func);
alias type = FunctionTypeOf!func;
template check(size_t i, mem...)
{
static if (i >= mem.length)
enum ptrdiff_t check = -1;
else
{
enum ptrdiff_t check =
__traits(identifier, func) == __traits(identifier, mem[i]) &&
!is(DerivedFunctionType!(type, FunctionTypeOf!(mem[i])) == void)
? i : check!(i + 1, mem);
}
}
enum ptrdiff_t x = 1 + check!(0, members[1 .. $]);
static if (x >= 1)
{
alias typex = DerivedFunctionType!(type, FunctionTypeOf!(members[x]));
alias remain = Uniq!(members[1 .. x], members[x + 1 .. $]);
static if (remain.length >= 1 && remain[0].name == name &&
!is(DerivedFunctionType!(typex, remain[0].type) == void))
{
alias F = DerivedFunctionType!(typex, remain[0].type);
alias Uniq = AliasSeq!(FuncInfo!(name, F), remain[1 .. $]);
}
else
alias Uniq = AliasSeq!(FuncInfo!(name, typex), remain);
}
else
{
alias Uniq = AliasSeq!(FuncInfo!(name, type), Uniq!(members[1 .. $]));
}
}
}
alias TargetMembers = Uniq!(Concat!()); // list of FuncInfo
alias SourceMembers = GetOverloadedMethods!Source; // list of function symbols
// Check whether all of SourceMembers satisfy covariance target in TargetMembers
template hasRequireMethods(size_t i = 0)
{
static if (i >= TargetMembers.length)
enum hasRequireMethods = true;
else
{
enum hasRequireMethods =
findCovariantFunction!(TargetMembers[i], Source, SourceMembers) != -1 &&
hasRequireMethods!(i + 1);
}
}
// Internal wrapper class
final class Impl : Structural, Targets
{
private:
Source _wrap_source;
this( inout Source s) inout @safe pure nothrow { _wrap_source = s; }
this(shared inout Source s) shared inout @safe pure nothrow { _wrap_source = s; }
// BUG: making private should work with NVI.
protected final inout(Object) _wrap_getSource() inout @trusted
{
return dynamicCast!(inout Object)(_wrap_source);
}
import std.conv : to;
import core.lifetime : forward;
template generateFun(size_t i)
{
enum name = TargetMembers[i].name;
enum fa = functionAttributes!(TargetMembers[i].type);
static @property stc()
{
string r;
if (fa & FunctionAttribute.property) r ~= "@property ";
if (fa & FunctionAttribute.ref_) r ~= "ref ";
if (fa & FunctionAttribute.pure_) r ~= "pure ";
if (fa & FunctionAttribute.nothrow_) r ~= "nothrow ";
if (fa & FunctionAttribute.trusted) r ~= "@trusted ";
if (fa & FunctionAttribute.safe) r ~= "@safe ";
return r;
}
static @property mod()
{
alias type = AliasSeq!(TargetMembers[i].type)[0];
string r;
static if (is(type == immutable)) r ~= " immutable";
else
{
static if (is(type == shared)) r ~= " shared";
static if (is(type == const)) r ~= " const";
else static if (is(type == inout)) r ~= " inout";
//else --> mutable
}
return r;
}
enum n = to!string(i);
static if (fa & FunctionAttribute.property)
{
static if (Parameters!(TargetMembers[i].type).length == 0)
enum fbody = "_wrap_source."~name;
else
enum fbody = "_wrap_source."~name~" = forward!args";
}
else
{
enum fbody = "_wrap_source."~name~"(forward!args)";
}
enum generateFun =
"override "~stc~"ReturnType!(TargetMembers["~n~"].type) "
~ name~"(Parameters!(TargetMembers["~n~"].type) args) "~mod~
"{ return "~fbody~"; }";
}
public:
static foreach (i; 0 .. TargetMembers.length)
mixin(generateFun!i);
}
}
}
/// ditto
template wrap(Targets...)
if (Targets.length >= 1 && !allSatisfy!(isMutable, Targets))
{
import std.meta : staticMap;
alias wrap = .wrap!(staticMap!(Unqual, Targets));
}
/// ditto
template unwrap(Target)
if (isMutable!Target)
{
// strict downcast
auto unwrap(Source)(inout Source src) @trusted pure nothrow
if (is(Target : Source))
{
alias T = Select!(is(Source == shared), shared Target, Target);
return dynamicCast!(inout T)(src);
}
// structural downcast
auto unwrap(Source)(inout Source src) @trusted pure nothrow
if (!is(Target : Source))
{
alias T = Select!(is(Source == shared), shared Target, Target);
Object o = dynamicCast!(Object)(src); // remove qualifier
do
{
if (auto a = dynamicCast!(Structural)(o))
{
if (auto d = dynamicCast!(inout T)(o = a._wrap_getSource()))
return d;
}
else if (auto d = dynamicCast!(inout T)(o))
return d;
else
break;
} while (o);
return null;
}
}
/// ditto
template unwrap(Target)
if (!isMutable!Target)
{
alias unwrap = .unwrap!(Unqual!Target);
}
///
@system unittest
{
interface Quack
{
int quack();
@property int height();
}
interface Flyer
{
@property int height();
}
class Duck : Quack
{
int quack() { return 1; }
@property int height() { return 10; }
}
class Human
{
int quack() { return 2; }
@property int height() { return 20; }
}
Duck d1 = new Duck();
Human h1 = new Human();
interface Refleshable
{
int reflesh();
}
// does not have structural conformance
static assert(!__traits(compiles, d1.wrap!Refleshable));
static assert(!__traits(compiles, h1.wrap!Refleshable));
// strict upcast
Quack qd = d1.wrap!Quack;
assert(qd is d1);
assert(qd.quack() == 1); // calls Duck.quack
// strict downcast
Duck d2 = qd.unwrap!Duck;
assert(d2 is d1);
// structural upcast
Quack qh = h1.wrap!Quack;
assert(qh.quack() == 2); // calls Human.quack
// structural downcast
Human h2 = qh.unwrap!Human;
assert(h2 is h1);
// structural upcast (two steps)
Quack qx = h1.wrap!Quack; // Human -> Quack
Flyer fx = qx.wrap!Flyer; // Quack -> Flyer
assert(fx.height == 20); // calls Human.height
// structural downcast (two steps)
Quack qy = fx.unwrap!Quack; // Flyer -> Quack
Human hy = qy.unwrap!Human; // Quack -> Human
assert(hy is h1);
// structural downcast (one step)
Human hz = fx.unwrap!Human; // Flyer -> Human
assert(hz is h1);
}
///
@system unittest
{
import std.traits : FunctionAttribute, functionAttributes;
interface A { int run(); }
interface B { int stop(); @property int status(); }
class X
{
int run() { return 1; }
int stop() { return 2; }
@property int status() { return 3; }
}
auto x = new X();
auto ab = x.wrap!(A, B);
A a = ab;
B b = ab;
assert(a.run() == 1);
assert(b.stop() == 2);
assert(b.status == 3);
static assert(functionAttributes!(typeof(ab).status) & FunctionAttribute.property);
}
// Internal class to support dynamic cross-casting
private interface Structural
{
inout(Object) _wrap_getSource() inout @safe pure nothrow;
}
@system unittest
{
class A
{
int draw() { return 1; }
int draw(int v) { return v; }
int draw() const { return 2; }
int draw() shared { return 3; }
int draw() shared const { return 4; }
int draw() immutable { return 5; }
}
interface Drawable
{
int draw();
int draw() const;
int draw() shared;
int draw() shared const;
int draw() immutable;
}
interface Drawable2
{
int draw(int v);
}
auto ma = new A();
auto sa = new shared A();
auto ia = new immutable A();
{
Drawable md = ma.wrap!Drawable;
const Drawable cd = ma.wrap!Drawable;
shared Drawable sd = sa.wrap!Drawable;
shared const Drawable scd = sa.wrap!Drawable;
immutable Drawable id = ia.wrap!Drawable;
assert( md.draw() == 1);
assert( cd.draw() == 2);
assert( sd.draw() == 3);
assert(scd.draw() == 4);
assert( id.draw() == 5);
}
{
Drawable2 d = ma.wrap!Drawable2;
static assert(!__traits(compiles, d.draw()));
assert(d.draw(10) == 10);
}
}
// https://issues.dlang.org/show_bug.cgi?id=10377
@system unittest
{
import std.range, std.algorithm;
interface MyInputRange(T)
{
@property T front();
void popFront();
@property bool empty();
}
//auto o = iota(0,10,1).inputRangeObject();
//pragma(msg, __traits(allMembers, typeof(o)));
auto r = iota(0,10,1).inputRangeObject().wrap!(MyInputRange!int)();
assert(equal(r, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
}
// https://issues.dlang.org/show_bug.cgi?id=10536
@system unittest
{
interface Interface
{
int foo();
}
class Pluggable
{
int foo() { return 1; }
@disable void opCast(T, this X)(); // !
}
Interface i = new Pluggable().wrap!Interface;
assert(i.foo() == 1);
}
@system unittest
{
// Enhancement 10538
interface Interface
{
int foo();
int bar(int);
}
class Pluggable
{
int opDispatch(string name, A...)(A args) { return 100; }
}
Interface i = wrap!Interface(new Pluggable());
assert(i.foo() == 100);
assert(i.bar(10) == 100);
}
// https://issues.dlang.org/show_bug.cgi?id=12064
@system unittest
{
interface I
{
int foo();
final int nvi1(){return foo();}
}
interface J
{
int bar();
final int nvi2(){return bar();}
}
class Baz
{
int foo() { return 42;}
int bar() { return 12064;}
}
auto baz = new Baz();
auto foobar = baz.wrap!(I, J)();
assert(foobar.nvi1 == 42);
assert(foobar.nvi2 == 12064);
}
// Make a tuple of non-static function symbols
package template GetOverloadedMethods(T)
{
import std.meta : Filter;
alias allMembers = __traits(allMembers, T);
template follows(size_t i = 0)
{
static if (i >= allMembers.length)
{
alias follows = AliasSeq!();
}
else static if (!__traits(compiles, mixin("T."~allMembers[i])))
{
alias follows = follows!(i + 1);
}
else
{
enum name = allMembers[i];
template isMethod(alias f)
{
static if (is(typeof(&f) F == F*) && is(F == function))
enum isMethod = !__traits(isStaticFunction, f);
else
enum isMethod = false;
}
alias follows = AliasSeq!(
std.meta.Filter!(isMethod, __traits(getOverloads, T, name)),
follows!(i + 1));
}
}
alias GetOverloadedMethods = follows!();
}
// find a function from Fs that has same identifier and covariant type with f
private template findCovariantFunction(alias finfo, Source, Fs...)
{
template check(size_t i = 0)
{
static if (i >= Fs.length)
enum ptrdiff_t check = -1;
else
{
enum ptrdiff_t check =
(finfo.name == __traits(identifier, Fs[i])) &&
isCovariantWith!(FunctionTypeOf!(Fs[i]), finfo.type)
? i : check!(i + 1);
}
}
enum x = check!();
static if (x == -1 && is(typeof(Source.opDispatch)))
{
alias Params = Parameters!(finfo.type);
enum ptrdiff_t findCovariantFunction =
is(typeof(( Source).init.opDispatch!(finfo.name)(Params.init))) ||
is(typeof(( const Source).init.opDispatch!(finfo.name)(Params.init))) ||
is(typeof(( immutable Source).init.opDispatch!(finfo.name)(Params.init))) ||
is(typeof(( shared Source).init.opDispatch!(finfo.name)(Params.init))) ||
is(typeof((shared const Source).init.opDispatch!(finfo.name)(Params.init)))
? ptrdiff_t.max : -1;
}
else
enum ptrdiff_t findCovariantFunction = x;
}
private enum TypeModifier
{
mutable = 0, // type is mutable
const_ = 1, // type is const
immutable_ = 2, // type is immutable
shared_ = 4, // type is shared
inout_ = 8, // type is wild
}
private template TypeMod(T)
{
static if (is(T == immutable))
{
enum mod1 = TypeModifier.immutable_;
enum mod2 = 0;
}
else
{
enum mod1 = is(T == shared) ? TypeModifier.shared_ : 0;
static if (is(T == const))
enum mod2 = TypeModifier.const_;
else static if (is(T == inout))
enum mod2 = TypeModifier.inout_;
else
enum mod2 = TypeModifier.mutable;
}
enum TypeMod = cast(TypeModifier)(mod1 | mod2);
}
@system unittest
{
template UnittestFuncInfo(alias f)
{
enum name = __traits(identifier, f);
alias type = FunctionTypeOf!f;
}
class A
{
int draw() { return 1; }
@property int value() { return 2; }
final int run() { return 3; }
}
alias methods = GetOverloadedMethods!A;
alias int F1();
alias @property int F2();
alias string F3();
alias nothrow @trusted uint F4();
alias int F5(Object);
alias bool F6(Object);
static assert(methods.length == 3 + 4);
static assert(__traits(identifier, methods[0]) == "draw" && is(typeof(&methods[0]) == F1*));
static assert(__traits(identifier, methods[1]) == "value" && is(typeof(&methods[1]) == F2*));
static assert(__traits(identifier, methods[2]) == "run" && is(typeof(&methods[2]) == F1*));
int draw();
@property int value();
void opEquals();
int nomatch();
static assert(findCovariantFunction!(UnittestFuncInfo!draw, A, methods) == 0);
static assert(findCovariantFunction!(UnittestFuncInfo!value, A, methods) == 1);
static assert(findCovariantFunction!(UnittestFuncInfo!opEquals, A, methods) == -1);
static assert(findCovariantFunction!(UnittestFuncInfo!nomatch, A, methods) == -1);
// considering opDispatch
class B
{
void opDispatch(string name, A...)(A) {}
}
alias methodsB = GetOverloadedMethods!B;
static assert(findCovariantFunction!(UnittestFuncInfo!draw, B, methodsB) == ptrdiff_t.max);
static assert(findCovariantFunction!(UnittestFuncInfo!value, B, methodsB) == ptrdiff_t.max);
static assert(findCovariantFunction!(UnittestFuncInfo!opEquals, B, methodsB) == ptrdiff_t.max);
static assert(findCovariantFunction!(UnittestFuncInfo!nomatch, B, methodsB) == ptrdiff_t.max);
}
package template DerivedFunctionType(T...)
{
static if (!T.length)
{
alias DerivedFunctionType = void;
}
else static if (T.length == 1)
{
static if (is(T[0] == function))
{
alias DerivedFunctionType = T[0];
}
else
{
alias DerivedFunctionType = void;
}
}
else static if (is(T[0] P0 == function) && is(T[1] P1 == function))
{
alias FA = FunctionAttribute;
alias F0 = T[0], R0 = ReturnType!F0, PSTC0 = ParameterStorageClassTuple!F0;
alias F1 = T[1], R1 = ReturnType!F1, PSTC1 = ParameterStorageClassTuple!F1;
enum FA0 = functionAttributes!F0;
enum FA1 = functionAttributes!F1;
template CheckParams(size_t i = 0)
{
static if (i >= P0.length)
enum CheckParams = true;
else
{
enum CheckParams = (is(P0[i] == P1[i]) && PSTC0[i] == PSTC1[i]) &&
CheckParams!(i + 1);
}
}
static if (R0.sizeof == R1.sizeof && !is(CommonType!(R0, R1) == void) &&
P0.length == P1.length && CheckParams!() && TypeMod!F0 == TypeMod!F1 &&
variadicFunctionStyle!F0 == variadicFunctionStyle!F1 &&
functionLinkage!F0 == functionLinkage!F1 &&
((FA0 ^ FA1) & (FA.ref_ | FA.property)) == 0)
{
alias R = Select!(is(R0 : R1), R0, R1);
alias FX = FunctionTypeOf!(R function(P0));
// @system is default
alias FY = SetFunctionAttributes!(FX, functionLinkage!F0, (FA0 | FA1) & ~FA.system);
alias DerivedFunctionType = DerivedFunctionType!(FY, T[2 .. $]);
}
else
alias DerivedFunctionType = void;
}
else
alias DerivedFunctionType = void;
}
@safe unittest
{
// attribute covariance
alias int F1();
static assert(is(DerivedFunctionType!(F1, F1) == F1));
alias int F2() pure nothrow;
static assert(is(DerivedFunctionType!(F1, F2) == F2));
alias int F3() @safe;
alias int F23() @safe pure nothrow;
static assert(is(DerivedFunctionType!(F2, F3) == F23));
// return type covariance
alias long F4();
static assert(is(DerivedFunctionType!(F1, F4) == void));
class C {}
class D : C {}
alias C F5();
alias D F6();
static assert(is(DerivedFunctionType!(F5, F6) == F6));
alias typeof(null) F7();
alias int[] F8();
alias int* F9();
static assert(is(DerivedFunctionType!(F5, F7) == F7));
static assert(is(DerivedFunctionType!(F7, F8) == void));
static assert(is(DerivedFunctionType!(F7, F9) == F7));
// variadic type equality
alias int F10(int);
alias int F11(int...);
alias int F12(int, ...);
static assert(is(DerivedFunctionType!(F10, F11) == void));
static assert(is(DerivedFunctionType!(F10, F12) == void));
static assert(is(DerivedFunctionType!(F11, F12) == void));
// linkage equality
alias extern(C) int F13(int);
alias extern(D) int F14(int);
alias extern(Windows) int F15(int);
static assert(is(DerivedFunctionType!(F13, F14) == void));
static assert(is(DerivedFunctionType!(F13, F15) == void));
static assert(is(DerivedFunctionType!(F14, F15) == void));
// ref & @property equality
alias int F16(int);
alias ref int F17(int);
alias @property int F18(int);
static assert(is(DerivedFunctionType!(F16, F17) == void));
static assert(is(DerivedFunctionType!(F16, F18) == void));
static assert(is(DerivedFunctionType!(F17, F18) == void));
}
package template Bind(alias Template, args1...)
{
alias Bind(args2...) = Template!(args1, args2);
}
/**
Options regarding auto-initialization of a `RefCounted` object (see
the definition of `RefCounted` below).
*/
enum RefCountedAutoInitialize
{
/// Do not auto-initialize the object
no,
/// Auto-initialize the object
yes,
}
///
@system unittest
{
import core.exception : AssertError;
import std.exception : assertThrown;
struct Foo
{
int a = 42;
}
RefCounted!(Foo, RefCountedAutoInitialize.yes) rcAuto;
RefCounted!(Foo, RefCountedAutoInitialize.no) rcNoAuto;
assert(rcAuto.refCountedPayload.a == 42);
assertThrown!AssertError(rcNoAuto.refCountedPayload);
rcNoAuto.refCountedStore.ensureInitialized;
assert(rcNoAuto.refCountedPayload.a == 42);
}
/**
Defines a reference-counted object containing a `T` value as
payload.
An instance of `RefCounted` is a reference to a structure,
which is referred to as the $(I store), or $(I storage implementation
struct) in this documentation. The store contains a reference count
and the `T` payload. `RefCounted` uses `malloc` to allocate
the store. As instances of `RefCounted` are copied or go out of
scope, they will automatically increment or decrement the reference
count. When the reference count goes down to zero, `RefCounted`
will call `destroy` against the payload and call `free` to
deallocate the store. If the `T` payload contains any references
to GC-allocated memory, then `RefCounted` will add it to the GC memory
that is scanned for pointers, and remove it from GC scanning before
`free` is called on the store.
One important consequence of `destroy` is that it will call the
destructor of the `T` payload. GC-managed references are not
guaranteed to be valid during a destructor call, but other members of
`T`, such as file handles or pointers to `malloc` memory, will
still be valid during the destructor call. This allows the `T` to
deallocate or clean up any non-GC resources immediately after the
reference count has reached zero.
`RefCounted` is unsafe and should be used with care. No references
to the payload should be escaped outside the `RefCounted` object.
The `autoInit` option makes the object ensure the store is
automatically initialized. Leaving $(D autoInit ==
RefCountedAutoInitialize.yes) (the default option) is convenient but
has the cost of a test whenever the payload is accessed. If $(D
autoInit == RefCountedAutoInitialize.no), user code must call either
`refCountedStore.isInitialized` or `refCountedStore.ensureInitialized`
before attempting to access the payload. Not doing so results in null
pointer dereference.
*/
struct RefCounted(T, RefCountedAutoInitialize autoInit =
RefCountedAutoInitialize.yes)
if (!is(T == class) && !(is(T == interface)))
{
version (D_BetterC)
{
private enum enableGCScan = false;
}
else
{
private enum enableGCScan = hasIndirections!T;
}
// TODO remove pure when https://issues.dlang.org/show_bug.cgi?id=15862 has been fixed
extern(C) private pure nothrow @nogc static
{
pragma(mangle, "free") void pureFree( void *ptr );
static if (enableGCScan)
{
pragma(mangle, "gc_addRange") void pureGcAddRange( in void* p, size_t sz, const TypeInfo ti = null );
pragma(mangle, "gc_removeRange") void pureGcRemoveRange( in void* p );
}
}
/// `RefCounted` storage implementation.
struct RefCountedStore
{
private struct Impl
{
T _payload;
size_t _count;
}
private Impl* _store;
private void initialize(A...)(auto ref A args)
{
import core.lifetime : emplace, forward;
allocateStore();
version (D_Exceptions) scope(failure) deallocateStore();
emplace(&_store._payload, forward!args);
_store._count = 1;
}
private void move(ref T source) nothrow pure
{
import std.algorithm.mutation : moveEmplace;
allocateStore();
moveEmplace(source, _store._payload);
_store._count = 1;
}
// 'nothrow': can only generate an Error
private void allocateStore() nothrow pure
{
static if (enableGCScan)
{
import std.internal.memory : enforceCalloc;
_store = cast(Impl*) enforceCalloc(1, Impl.sizeof);
pureGcAddRange(&_store._payload, T.sizeof);
}
else
{
import std.internal.memory : enforceMalloc;
_store = cast(Impl*) enforceMalloc(Impl.sizeof);
}
}
private void deallocateStore() nothrow pure
{
static if (enableGCScan)
{
pureGcRemoveRange(&this._store._payload);
}
pureFree(_store);
_store = null;
}
/**
Returns `true` if and only if the underlying store has been
allocated and initialized.
*/
@property nothrow @safe pure @nogc
bool isInitialized() const
{
return _store !is null;
}
/**
Returns underlying reference count if it is allocated and initialized
(a positive integer), and `0` otherwise.
*/
@property nothrow @safe pure @nogc
size_t refCount() const
{
return isInitialized ? _store._count : 0;
}
/**
Makes sure the payload was properly initialized. Such a
call is typically inserted before using the payload.
*/
void ensureInitialized()
{
if (!isInitialized) initialize();
}
}
RefCountedStore _refCounted;
/// Returns storage implementation struct.
@property nothrow @safe
ref inout(RefCountedStore) refCountedStore() inout
{
return _refCounted;
}
/**
Constructor that initializes the payload.
Postcondition: `refCountedStore.isInitialized`
*/
this(A...)(auto ref A args) if (A.length > 0)
out
{
assert(refCountedStore.isInitialized);
}
do
{
import core.lifetime : forward;
_refCounted.initialize(forward!args);
}
/// Ditto
this(T val)
{
_refCounted.move(val);
}
/**
Constructor that tracks the reference count appropriately. If $(D
!refCountedStore.isInitialized), does nothing.
*/
this(this) @safe pure nothrow @nogc
{
if (!_refCounted.isInitialized) return;
++_refCounted._store._count;
}
/**
Destructor that tracks the reference count appropriately. If $(D
!refCountedStore.isInitialized), does nothing. When the reference count goes
down to zero, calls `destroy` agaist the payload and calls `free`
to deallocate the corresponding resource.
*/
~this()
{
if (!_refCounted.isInitialized) return;
assert(_refCounted._store._count > 0);
if (--_refCounted._store._count)
return;
// Done, destroy and deallocate
.destroy(_refCounted._store._payload);
_refCounted.deallocateStore();
}
/**
Assignment operators
*/
void opAssign(typeof(this) rhs)
{
import std.algorithm.mutation : swap;
swap(_refCounted._store, rhs._refCounted._store);
}
/// Ditto
void opAssign(T rhs)
{
import std.algorithm.mutation : move;
static if (autoInit == RefCountedAutoInitialize.yes)
{
_refCounted.ensureInitialized();
}
else
{
assert(_refCounted.isInitialized);
}
move(rhs, _refCounted._store._payload);
}
//version to have a single properly ddoc'ed function (w/ correct sig)
version (StdDdoc)
{
/**
Returns a reference to the payload. If (autoInit ==
RefCountedAutoInitialize.yes), calls $(D
refCountedStore.ensureInitialized). Otherwise, just issues $(D
assert(refCountedStore.isInitialized)). Used with $(D alias
refCountedPayload this;), so callers can just use the `RefCounted`
object as a `T`.
$(BLUE The first overload exists only if $(D autoInit == RefCountedAutoInitialize.yes).)
So if $(D autoInit == RefCountedAutoInitialize.no)
or called for a constant or immutable object, then
`refCountedPayload` will also be qualified as safe and nothrow
(but will still assert if not initialized).
*/
@property @trusted
ref T refCountedPayload() return;
/// ditto
@property nothrow @safe pure @nogc
ref inout(T) refCountedPayload() inout return;
}
else
{
static if (autoInit == RefCountedAutoInitialize.yes)
{
//Can't use inout here because of potential mutation
@property
ref T refCountedPayload() return
{
_refCounted.ensureInitialized();
return _refCounted._store._payload;
}
}
@property nothrow @safe pure @nogc
ref inout(T) refCountedPayload() inout return
{
assert(_refCounted.isInitialized, "Attempted to access an uninitialized payload.");
return _refCounted._store._payload;
}
}
/**
Returns a reference to the payload. If (autoInit ==
RefCountedAutoInitialize.yes), calls $(D
refCountedStore.ensureInitialized). Otherwise, just issues $(D
assert(refCountedStore.isInitialized)).
*/
alias refCountedPayload this;
}
///
@betterC pure @system nothrow @nogc unittest
{
// A pair of an `int` and a `size_t` - the latter being the
// reference count - will be dynamically allocated
auto rc1 = RefCounted!int(5);
assert(rc1 == 5);
// No more allocation, add just one extra reference count
auto rc2 = rc1;
// Reference semantics
rc2 = 42;
assert(rc1 == 42);
// the pair will be freed when rc1 and rc2 go out of scope
}
pure @system unittest
{
RefCounted!int* p;
{
auto rc1 = RefCounted!int(5);
p = &rc1;
assert(rc1 == 5);
assert(rc1._refCounted._store._count == 1);
auto rc2 = rc1;
assert(rc1._refCounted._store._count == 2);
// Reference semantics
rc2 = 42;
assert(rc1 == 42);
rc2 = rc2;
assert(rc2._refCounted._store._count == 2);
rc1 = rc2;
assert(rc1._refCounted._store._count == 2);
}
assert(p._refCounted._store == null);
// RefCounted as a member
struct A
{
RefCounted!int x;
this(int y)
{
x._refCounted.initialize(y);
}
A copy()
{
auto another = this;
return another;
}
}
auto a = A(4);
auto b = a.copy();
assert(a.x._refCounted._store._count == 2,
"https://issues.dlang.org/show_bug.cgi?id=4356 still unfixed");
}
@betterC pure @system nothrow @nogc unittest
{
import std.algorithm.mutation : swap;
RefCounted!int p1, p2;
swap(p1, p2);
}
// https://issues.dlang.org/show_bug.cgi?id=6606
@betterC @safe pure nothrow @nogc unittest
{
union U {
size_t i;
void* p;
}
struct S {
U u;
}
alias SRC = RefCounted!S;
}
// https://issues.dlang.org/show_bug.cgi?id=6436
@betterC @system pure unittest
{
struct S
{
this(int rval) { assert(rval == 1); }
this(ref int lval) { assert(lval == 3); ++lval; }
}
auto s1 = RefCounted!S(1);
int lval = 3;
auto s2 = RefCounted!S(lval);
assert(lval == 4);
}
// gc_addRange coverage
@betterC @system pure unittest
{
struct S { int* p; }
auto s = RefCounted!S(null);
}
@betterC @system pure nothrow @nogc unittest
{
RefCounted!int a;
a = 5; //This should not assert
assert(a == 5);
RefCounted!int b;
b = a; //This should not assert either
assert(b == 5);
RefCounted!(int*) c;
}
/**
* Initializes a `RefCounted` with `val`. The template parameter
* `T` of `RefCounted` is inferred from `val`.
* This function can be used to move non-copyable values to the heap.
* It also disables the `autoInit` option of `RefCounted`.
*
* Params:
* val = The value to be reference counted
* Returns:
* An initialized `RefCounted` containing `val`.
* See_Also:
* $(HTTP en.cppreference.com/w/cpp/memory/shared_ptr/make_shared, C++'s make_shared)
*/
RefCounted!(T, RefCountedAutoInitialize.no) refCounted(T)(T val)
{
typeof(return) res;
res._refCounted.move(val);
return res;
}
///
@system unittest
{
static struct File
{
string name;
@disable this(this); // not copyable
~this() { name = null; }
}
auto file = File("name");
assert(file.name == "name");
// file cannot be copied and has unique ownership
static assert(!__traits(compiles, {auto file2 = file;}));
// make the file refcounted to share ownership
import std.algorithm.mutation : move;
auto rcFile = refCounted(move(file));
assert(rcFile.name == "name");
assert(file.name == null);
auto rcFile2 = rcFile;
assert(rcFile.refCountedStore.refCount == 2);
// file gets properly closed when last reference is dropped
}
/**
Creates a proxy for the value `a` that will forward all operations
while disabling implicit conversions. The aliased item `a` must be
an $(B lvalue). This is useful for creating a new type from the
"base" type (though this is $(B not) a subtype-supertype
relationship; the new type is not related to the old type in any way,
by design).
The new type supports all operations that the underlying type does,
including all operators such as `+`, `--`, `<`, `[]`, etc.
Params:
a = The value to act as a proxy for all operations. It must
be an lvalue.
*/
mixin template Proxy(alias a)
{
private alias ValueType = typeof({ return a; }());
/* Determine if 'T.a' can referenced via a const(T).
* Use T* as the parameter because 'scope' inference needs a fully
* analyzed T, which doesn't work when accessibleFrom() is used in a
* 'static if' in the definition of Proxy or T.
*/
private enum bool accessibleFrom(T) =
is(typeof((T* self){ cast(void) mixin("(*self)."~__traits(identifier, a)); }));
static if (is(typeof(this) == class))
{
override bool opEquals(Object o)
{
if (auto b = cast(typeof(this))o)
{
return a == mixin("b."~__traits(identifier, a));
}
return false;
}
bool opEquals(T)(T b)
if (is(ValueType : T) || is(typeof(a.opEquals(b))) || is(typeof(b.opEquals(a))))
{
static if (is(typeof(a.opEquals(b))))
return a.opEquals(b);
else static if (is(typeof(b.opEquals(a))))
return b.opEquals(a);
else
return a == b;
}
override int opCmp(Object o)
{
if (auto b = cast(typeof(this))o)
{
return a < mixin("b."~__traits(identifier, a)) ? -1
: a > mixin("b."~__traits(identifier, a)) ? +1 : 0;
}
static if (is(ValueType == class))
return a.opCmp(o);
else
throw new Exception("Attempt to compare a "~typeid(this).toString~" and a "~typeid(o).toString);
}
int opCmp(T)(auto ref const T b)
if (is(ValueType : T) || is(typeof(a.opCmp(b))) || is(typeof(b.opCmp(a))))
{
static if (is(typeof(a.opCmp(b))))
return a.opCmp(b);
else static if (is(typeof(b.opCmp(a))))
return -b.opCmp(b);
else
return a < b ? -1 : a > b ? +1 : 0;
}
static if (accessibleFrom!(const typeof(this)))
{
override size_t toHash() const nothrow @safe
{
static if (__traits(compiles, .hashOf(a)))
return .hashOf(a);
else
// Workaround for when .hashOf is not both @safe and nothrow.
{
static if (is(typeof(&a) == ValueType*))
alias v = a;
else
auto v = a; // if a is (property) function
// BUG: Improperly casts away `shared`!
return typeid(ValueType).getHash((() @trusted => cast(const void*) &v)());
}
}
}
}
else
{
auto ref opEquals(this X, B)(auto ref B b)
{
static if (is(immutable B == immutable typeof(this)))
{
return a == mixin("b."~__traits(identifier, a));
}
else
return a == b;
}
auto ref opCmp(this X, B)(auto ref B b)
{
static if (is(typeof(a.opCmp(b))))
return a.opCmp(b);
else static if (is(typeof(b.opCmp(a))))
return -b.opCmp(a);
else static if (isFloatingPoint!ValueType || isFloatingPoint!B)
return a < b ? -1 : a > b ? +1 : a == b ? 0 : float.nan;
else
return a < b ? -1 : (a > b);
}
static if (accessibleFrom!(const typeof(this)))
{
size_t toHash() const nothrow @safe
{
static if (__traits(compiles, .hashOf(a)))
return .hashOf(a);
else
// Workaround for when .hashOf is not both @safe and nothrow.
{
static if (is(typeof(&a) == ValueType*))
alias v = a;
else
auto v = a; // if a is (property) function
// BUG: Improperly casts away `shared`!
return typeid(ValueType).getHash((() @trusted => cast(const void*) &v)());
}
}
}
}
auto ref opCall(this X, Args...)(auto ref Args args) { return a(args); }
auto ref opCast(T, this X)() { return cast(T) a; }
auto ref opIndex(this X, D...)(auto ref D i) { return a[i]; }
auto ref opSlice(this X )() { return a[]; }
auto ref opSlice(this X, B, E)(auto ref B b, auto ref E e) { return a[b .. e]; }
auto ref opUnary (string op, this X )() { return mixin(op~"a"); }
auto ref opIndexUnary(string op, this X, D...)(auto ref D i) { return mixin(op~"a[i]"); }
auto ref opSliceUnary(string op, this X )() { return mixin(op~"a[]"); }
auto ref opSliceUnary(string op, this X, B, E)(auto ref B b, auto ref E e) { return mixin(op~"a[b .. e]"); }
auto ref opBinary(string op, this X, B)(auto ref B b)
if (op == "in" && is(typeof(a in b)) || op != "in")
{
return mixin("a "~op~" b");
}
auto ref opBinaryRight(string op, this X, B)(auto ref B b) { return mixin("b "~op~" a"); }
static if (!is(typeof(this) == class))
{
import std.traits;
static if (isAssignable!ValueType)
{
auto ref opAssign(this X)(auto ref typeof(this) v)
{
a = mixin("v."~__traits(identifier, a));
return this;
}
}
else
{
@disable void opAssign(this X)(auto ref typeof(this) v);
}
}
auto ref opAssign (this X, V )(auto ref V v) if (!is(V == typeof(this))) { return a = v; }
auto ref opIndexAssign(this X, V, D...)(auto ref V v, auto ref D i) { return a[i] = v; }
auto ref opSliceAssign(this X, V )(auto ref V v) { return a[] = v; }
auto ref opSliceAssign(this X, V, B, E)(auto ref V v, auto ref B b, auto ref E e) { return a[b .. e] = v; }
auto ref opOpAssign (string op, this X, V )(auto ref V v)
{
return mixin("a = a "~op~" v");
}
auto ref opIndexOpAssign(string op, this X, V, D...)(auto ref V v, auto ref D i)
{
return mixin("a[i] " ~op~"= v");
}
auto ref opSliceOpAssign(string op, this X, V )(auto ref V v)
{
return mixin("a[] " ~op~"= v");
}
auto ref opSliceOpAssign(string op, this X, V, B, E)(auto ref V v, auto ref B b, auto ref E e)
{
return mixin("a[b .. e] "~op~"= v");
}
template opDispatch(string name)
{
static if (is(typeof(__traits(getMember, a, name)) == function))
{
// non template function
auto ref opDispatch(this X, Args...)(auto ref Args args) { return mixin("a."~name~"(args)"); }
}
else static if (is(typeof({ enum x = mixin("a."~name); })))
{
// built-in type field, manifest constant, and static non-mutable field
enum opDispatch = mixin("a."~name);
}
else static if (is(typeof(mixin("a."~name))) || __traits(getOverloads, a, name).length != 0)
{
// field or property function
@property auto ref opDispatch(this X)() { return mixin("a."~name); }
@property auto ref opDispatch(this X, V)(auto ref V v) { return mixin("a."~name~" = v"); }
}
else
{
// member template
template opDispatch(T...)
{
enum targs = T.length ? "!T" : "";
auto ref opDispatch(this X, Args...)(auto ref Args args){ return mixin("a."~name~targs~"(args)"); }
}
}
}
import std.traits : isArray;
static if (isArray!ValueType)
{
auto opDollar() const { return a.length; }
}
else static if (is(typeof(a.opDollar!0)))
{
auto ref opDollar(size_t pos)() { return a.opDollar!pos(); }
}
else static if (is(typeof(a.opDollar) == function))
{
auto ref opDollar() { return a.opDollar(); }
}
else static if (is(typeof(a.opDollar)))
{
alias opDollar = a.opDollar;
}
}
///
@safe unittest
{
struct MyInt
{
private int value;
mixin Proxy!value;
this(int n){ value = n; }
}
MyInt n = 10;
// Enable operations that original type has.
++n;
assert(n == 11);
assert(n * 2 == 22);
void func(int n) { }
// Disable implicit conversions to original type.
//int x = n;
//func(n);
}
///The proxied value must be an $(B lvalue).
@safe unittest
{
struct NewIntType
{
//Won't work; the literal '1'
//is an rvalue, not an lvalue
//mixin Proxy!1;
//Okay, n is an lvalue
int n;
mixin Proxy!n;
this(int n) { this.n = n; }
}
NewIntType nit = 0;
nit++;
assert(nit == 1);
struct NewObjectType
{
Object obj;
//Ok, obj is an lvalue
mixin Proxy!obj;
this (Object o) { obj = o; }
}
NewObjectType not = new Object();
assert(__traits(compiles, not.toHash()));
}
/**
There is one exception to the fact that the new type is not related to the
old type. $(DDSUBLINK spec/function,pseudo-member, Pseudo-member)
functions are usable with the new type; they will be forwarded on to the
proxied value.
*/
@safe unittest
{
import std.math;
float f = 1.0;
assert(!f.isInfinity);
struct NewFloat
{
float _;
mixin Proxy!_;
this(float f) { _ = f; }
}
NewFloat nf = 1.0f;
assert(!nf.isInfinity);
}
@safe unittest
{
static struct MyInt
{
private int value;
mixin Proxy!value;
this(int n) inout { value = n; }
enum str = "str";
static immutable arr = [1,2,3];
}
static foreach (T; AliasSeq!(MyInt, const MyInt, immutable MyInt))
{{
T m = 10;
static assert(!__traits(compiles, { int x = m; }));
static assert(!__traits(compiles, { void func(int n){} func(m); }));
assert(m == 10);
assert(m != 20);
assert(m < 20);
assert(+m == 10);
assert(-m == -10);
assert(cast(double) m == 10.0);
assert(m + 10 == 20);
assert(m - 5 == 5);
assert(m * 20 == 200);
assert(m / 2 == 5);
assert(10 + m == 20);
assert(15 - m == 5);
assert(20 * m == 200);
assert(50 / m == 5);
static if (is(T == MyInt)) // mutable
{
assert(++m == 11);
assert(m++ == 11); assert(m == 12);
assert(--m == 11);
assert(m-- == 11); assert(m == 10);
m = m;
m = 20; assert(m == 20);
}
static assert(T.max == int.max);
static assert(T.min == int.min);
static assert(T.init == int.init);
static assert(T.str == "str");
static assert(T.arr == [1,2,3]);
}}
}
@system unittest
{
static struct MyArray
{
private int[] value;
mixin Proxy!value;
this(int[] arr) { value = arr; }
this(immutable int[] arr) immutable { value = arr; }
}
static foreach (T; AliasSeq!(MyArray, const MyArray, immutable MyArray))
{{
static if (is(T == immutable) && !is(typeof({ T a = [1,2,3,4]; })))
T a = [1,2,3,4].idup; // workaround until qualified ctor is properly supported
else
T a = [1,2,3,4];
assert(a == [1,2,3,4]);
assert(a != [5,6,7,8]);
assert(+a[0] == 1);
version (LittleEndian)
assert(cast(ulong[]) a == [0x0000_0002_0000_0001, 0x0000_0004_0000_0003]);
else
assert(cast(ulong[]) a == [0x0000_0001_0000_0002, 0x0000_0003_0000_0004]);
assert(a ~ [10,11] == [1,2,3,4,10,11]);
assert(a[0] == 1);
assert(a[] == [1,2,3,4]);
assert(a[2 .. 4] == [3,4]);
static if (is(T == MyArray)) // mutable
{
a = a;
a = [5,6,7,8]; assert(a == [5,6,7,8]);
a[0] = 0; assert(a == [0,6,7,8]);
a[] = 1; assert(a == [1,1,1,1]);
a[0 .. 3] = 2; assert(a == [2,2,2,1]);
a[0] += 2; assert(a == [4,2,2,1]);
a[] *= 2; assert(a == [8,4,4,2]);
a[0 .. 2] /= 2; assert(a == [4,2,4,2]);
}
}}
}
@system unittest
{
class Foo
{
int field;
@property int val1() const { return field; }
@property void val1(int n) { field = n; }
@property ref int val2() { return field; }
int func(int x, int y) const { return x; }
void func1(ref int a) { a = 9; }
T ifti1(T)(T t) { return t; }
void ifti2(Args...)(Args args) { }
void ifti3(T, Args...)(Args args) { }
T opCast(T)(){ return T.init; }
T tempfunc(T)() { return T.init; }
}
class Hoge
{
Foo foo;
mixin Proxy!foo;
this(Foo f) { foo = f; }
}
auto h = new Hoge(new Foo());
int n;
static assert(!__traits(compiles, { Foo f = h; }));
// field
h.field = 1; // lhs of assign
n = h.field; // rhs of assign
assert(h.field == 1); // lhs of BinExp
assert(1 == h.field); // rhs of BinExp
assert(n == 1);
// getter/setter property function
h.val1 = 4;
n = h.val1;
assert(h.val1 == 4);
assert(4 == h.val1);
assert(n == 4);
// ref getter property function
h.val2 = 8;
n = h.val2;
assert(h.val2 == 8);
assert(8 == h.val2);
assert(n == 8);
// member function
assert(h.func(2,4) == 2);
h.func1(n);
assert(n == 9);
// IFTI
assert(h.ifti1(4) == 4);
h.ifti2(4);
h.ifti3!int(4, 3);
// https://issues.dlang.org/show_bug.cgi?id=5896 test
assert(h.opCast!int() == 0);
assert(cast(int) h == 0);
const ih = new const Hoge(new Foo());
static assert(!__traits(compiles, ih.opCast!int()));
static assert(!__traits(compiles, cast(int) ih));
// template member function
assert(h.tempfunc!int() == 0);
}
@system unittest // about Proxy inside a class
{
class MyClass
{
int payload;
mixin Proxy!payload;
this(int i){ payload = i; }
string opCall(string msg){ return msg; }
int pow(int i){ return payload ^^ i; }
}
class MyClass2
{
MyClass payload;
mixin Proxy!payload;
this(int i){ payload = new MyClass(i); }
}
class MyClass3
{
int payload;
mixin Proxy!payload;
this(int i){ payload = i; }
}
// opEquals
Object a = new MyClass(5);
Object b = new MyClass(5);
Object c = new MyClass2(5);
Object d = new MyClass3(5);
assert(a == b);
assert((cast(MyClass) a) == 5);
assert(5 == (cast(MyClass) b));
assert(5 == cast(MyClass2) c);
assert(a != d);
assert(c != a);
// oops! above line is unexpected, isn't it?
// the reason is below.
// MyClass2.opEquals knows MyClass but,
// MyClass.opEquals doesn't know MyClass2.
// so, c.opEquals(a) is true, but a.opEquals(c) is false.
// furthermore, opEquals(T) couldn't be invoked.
assert((cast(MyClass2) c) != (cast(MyClass) a));
// opCmp
Object e = new MyClass2(7);
assert(a < cast(MyClass2) e); // OK. and
assert(e > a); // OK, but...
// assert(a < e); // RUNTIME ERROR!
// assert((cast(MyClass) a) < e); // RUNTIME ERROR!
assert(3 < cast(MyClass) a);
assert((cast(MyClass2) e) < 11);
// opCall
assert((cast(MyClass2) e)("hello") == "hello");
// opCast
assert((cast(MyClass)(cast(MyClass2) c)) == a);
assert((cast(int)(cast(MyClass2) c)) == 5);
// opIndex
class MyClass4
{
string payload;
mixin Proxy!payload;
this(string s){ payload = s; }
}
class MyClass5
{
MyClass4 payload;
mixin Proxy!payload;
this(string s){ payload = new MyClass4(s); }
}
auto f = new MyClass4("hello");
assert(f[1] == 'e');
auto g = new MyClass5("hello");
assert(f[1] == 'e');
// opSlice
assert(f[2 .. 4] == "ll");
// opUnary
assert(-(cast(MyClass2) c) == -5);
// opBinary
assert((cast(MyClass) a) + (cast(MyClass2) c) == 10);
assert(5 + cast(MyClass) a == 10);
// opAssign
(cast(MyClass2) c) = 11;
assert((cast(MyClass2) c) == 11);
(cast(MyClass2) c) = new MyClass(13);
assert((cast(MyClass2) c) == 13);
// opOpAssign
assert((cast(MyClass2) c) += 4);
assert((cast(MyClass2) c) == 17);
// opDispatch
assert((cast(MyClass2) c).pow(2) == 289);
// opDollar
assert(f[2..$-1] == "ll");
// toHash
int[Object] hash;
hash[a] = 19;
hash[c] = 21;
assert(hash[b] == 19);
assert(hash[c] == 21);
}
@safe unittest
{
struct MyInt
{
int payload;
mixin Proxy!payload;
}
MyInt v;
v = v;
struct Foo
{
@disable void opAssign(typeof(this));
}
struct MyFoo
{
Foo payload;
mixin Proxy!payload;
}
MyFoo f;
static assert(!__traits(compiles, f = f));
struct MyFoo2
{
Foo payload;
mixin Proxy!payload;
// override default Proxy behavior
void opAssign(typeof(this) rhs){}
}
MyFoo2 f2;
f2 = f2;
}
// https://issues.dlang.org/show_bug.cgi?id=8613
@safe unittest
{
static struct Name
{
mixin Proxy!val;
private string val;
this(string s) { val = s; }
}
bool[Name] names;
names[Name("a")] = true;
bool* b = Name("a") in names;
}
// workaround for https://issues.dlang.org/show_bug.cgi?id=19669
private enum isDIP1000 = __traits(compiles, () @safe {
int x;
int* p;
p = &x;
});
// excludes struct S; it's 'mixin Proxy!foo' doesn't compile with -dip1000
static if (isDIP1000) {} else
@system unittest
{
// https://issues.dlang.org/show_bug.cgi?id=14213
// using function for the payload
static struct S
{
int foo() { return 12; }
mixin Proxy!foo;
}
S s;
assert(s + 1 == 13);
assert(s * 2 == 24);
}
@system unittest
{
static class C
{
int foo() { return 12; }
mixin Proxy!foo;
}
C c = new C();
}
// Check all floating point comparisons for both Proxy and Typedef,
// also against int and a Typedef!int, to be as regression-proof
// as possible. https://issues.dlang.org/show_bug.cgi?id=15561
@safe unittest
{
static struct MyFloatImpl
{
float value;
mixin Proxy!value;
}
static void allFail(T0, T1)(T0 a, T1 b)
{
assert(!(a == b));
assert(!(a<b));
assert(!(a <= b));
assert(!(a>b));
assert(!(a >= b));
}
static foreach (T1; AliasSeq!(MyFloatImpl, Typedef!float, Typedef!double,
float, real, Typedef!int, int))
{
static foreach (T2; AliasSeq!(MyFloatImpl, Typedef!float))
{{
T1 a;
T2 b;
static if (isFloatingPoint!T1 || isFloatingPoint!(TypedefType!T1))
allFail(a, b);
a = 3;
allFail(a, b);
b = 4;
assert(a != b);
assert(a<b);
assert(a <= b);
assert(!(a>b));
assert(!(a >= b));
a = 4;
assert(a == b);
assert(!(a<b));
assert(a <= b);
assert(!(a>b));
assert(a >= b);
}}
}
}
/**
$(B Typedef) allows the creation of a unique type which is
based on an existing type. Unlike the `alias` feature,
$(B Typedef) ensures the two types are not considered as equals.
Params:
init = Optional initial value for the new type.
cookie = Optional, used to create multiple unique types which are
based on the same origin type `T`
Note: If a library routine cannot handle the Typedef type,
you can use the `TypedefType` template to extract the
type which the Typedef wraps.
*/
struct Typedef(T, T init = T.init, string cookie=null)
{
private T Typedef_payload = init;
// https://issues.dlang.org/show_bug.cgi?id=18415
// prevent default construction if original type does too.
static if ((is(T == struct) || is(T == union)) && !is(typeof({T t;})))
{
@disable this();
}
this(T init)
{
Typedef_payload = init;
}
this(Typedef tdef)
{
this(tdef.Typedef_payload);
}
// We need to add special overload for cast(Typedef!X) exp,
// thus we can't simply inherit Proxy!Typedef_payload
T2 opCast(T2 : Typedef!(T, Unused), this X, T, Unused...)()
{
return T2(cast(T) Typedef_payload);
}
auto ref opCast(T2, this X)()
{
return cast(T2) Typedef_payload;
}
mixin Proxy!Typedef_payload;
pure nothrow @nogc @safe @property
{
alias TD = typeof(this);
static if (isIntegral!T)
{
static TD min() {return TD(T.min);}
static TD max() {return TD(T.max);}
}
else static if (isFloatingPoint!T)
{
static TD infinity() {return TD(T.infinity);}
static TD nan() {return TD(T.nan);}
static TD dig() {return TD(T.dig);}
static TD epsilon() {return TD(T.epsilon);}
static TD mant_dig() {return TD(T.mant_dig);}
static TD max_10_exp() {return TD(T.max_10_exp);}
static TD max_exp() {return TD(T.max_exp);}
static TD min_10_exp() {return TD(T.min_10_exp);}
static TD min_exp() {return TD(T.min_exp);}
static TD max() {return TD(T.max);}
static TD min_normal() {return TD(T.min_normal);}
TD re() {return TD(Typedef_payload.re);}
TD im() {return TD(Typedef_payload.im);}
}
}
/**
* Convert wrapped value to a human readable string
*/
string toString(this T)()
{
import std.array : appender;
auto app = appender!string();
auto spec = singleSpec("%s");
toString(app, spec);
return app.data;
}
/// ditto
void toString(this T, W)(ref W writer, scope const ref FormatSpec!char fmt)
if (isOutputRange!(W, char))
{
formatValue(writer, Typedef_payload, fmt);
}
///
@safe unittest
{
import std.conv : to;
int i = 123;
auto td = Typedef!int(i);
assert(i.to!string == td.to!string);
}
}
///
@safe unittest
{
alias MyInt = Typedef!int;
MyInt foo = 10;
foo++;
assert(foo == 11);
}
/// custom initialization values
@safe unittest
{
alias MyIntInit = Typedef!(int, 42);
static assert(is(TypedefType!MyIntInit == int));
static assert(MyIntInit() == 42);
}
/// Typedef creates a new type
@safe unittest
{
alias MyInt = Typedef!int;
static void takeInt(int) {}
static void takeMyInt(MyInt) {}
int i;
takeInt(i); // ok
static assert(!__traits(compiles, takeMyInt(i)));
MyInt myInt;
static assert(!__traits(compiles, takeInt(myInt)));
takeMyInt(myInt); // ok
}
/// Use the optional `cookie` argument to create different types of the same base type
@safe unittest
{
alias TypeInt1 = Typedef!int;
alias TypeInt2 = Typedef!int;
// The two Typedefs are the same type.
static assert(is(TypeInt1 == TypeInt2));
alias MoneyEuros = Typedef!(float, float.init, "euros");
alias MoneyDollars = Typedef!(float, float.init, "dollars");
// The two Typedefs are _not_ the same type.
static assert(!is(MoneyEuros == MoneyDollars));
}
// https://issues.dlang.org/show_bug.cgi?id=12461
@safe unittest
{
alias Int = Typedef!int;
Int a, b;
a += b;
assert(a == 0);
}
/**
Get the underlying type which a `Typedef` wraps.
If `T` is not a `Typedef` it will alias itself to `T`.
*/
template TypedefType(T)
{
static if (is(T : Typedef!Arg, Arg))
alias TypedefType = Arg;
else
alias TypedefType = T;
}
///
@safe unittest
{
import std.conv : to;
alias MyInt = Typedef!int;
static assert(is(TypedefType!MyInt == int));
/// Instantiating with a non-Typedef will return that type
static assert(is(TypedefType!int == int));
string num = "5";
// extract the needed type
MyInt myInt = MyInt( num.to!(TypedefType!MyInt) );
assert(myInt == 5);
// cast to the underlying type to get the value that's being wrapped
int x = cast(TypedefType!MyInt) myInt;
alias MyIntInit = Typedef!(int, 42);
static assert(is(TypedefType!MyIntInit == int));
static assert(MyIntInit() == 42);
}
@safe unittest
{
Typedef!int x = 10;
static assert(!__traits(compiles, { int y = x; }));
static assert(!__traits(compiles, { long z = x; }));
Typedef!int y = 10;
assert(x == y);
static assert(Typedef!int.init == int.init);
Typedef!(float, 1.0) z; // specifies the init
assert(z == 1.0);
static assert(typeof(z).init == 1.0);
alias Dollar = Typedef!(int, 0, "dollar");
alias Yen = Typedef!(int, 0, "yen");
static assert(!is(Dollar == Yen));
Typedef!(int[3]) sa;
static assert(sa.length == 3);
static assert(typeof(sa).length == 3);
Typedef!(int[3]) dollar1;
assert(dollar1[0..$] is dollar1[0 .. 3]);
Typedef!(int[]) dollar2;
dollar2.length = 3;
assert(dollar2[0..$] is dollar2[0 .. 3]);
static struct Dollar1
{
static struct DollarToken {}
enum opDollar = DollarToken.init;
auto opSlice(size_t, DollarToken) { return 1; }
auto opSlice(size_t, size_t) { return 2; }
}
Typedef!Dollar1 drange1;
assert(drange1[0..$] == 1);
assert(drange1[0 .. 1] == 2);
static struct Dollar2
{
size_t opDollar(size_t pos)() { return pos == 0 ? 1 : 100; }
size_t opIndex(size_t i, size_t j) { return i + j; }
}
Typedef!Dollar2 drange2;
assert(drange2[$, $] == 101);
static struct Dollar3
{
size_t opDollar() { return 123; }
size_t opIndex(size_t i) { return i; }
}
Typedef!Dollar3 drange3;
assert(drange3[$] == 123);
}
// https://issues.dlang.org/show_bug.cgi?id=18415
@safe @nogc pure nothrow unittest
{
struct NoDefCtorS{@disable this();}
union NoDefCtorU{@disable this();}
static assert(!is(typeof({Typedef!NoDefCtorS s;})));
static assert(!is(typeof({Typedef!NoDefCtorU u;})));
}
// https://issues.dlang.org/show_bug.cgi?id=11703
@safe @nogc pure nothrow unittest
{
alias I = Typedef!int;
static assert(is(typeof(I.min) == I));
static assert(is(typeof(I.max) == I));
alias F = Typedef!double;
static assert(is(typeof(F.infinity) == F));
static assert(is(typeof(F.epsilon) == F));
F f;
assert(!is(typeof(F.re).stringof == double));
assert(!is(typeof(F.im).stringof == double));
}
@safe unittest
{
// https://issues.dlang.org/show_bug.cgi?id=8655
import std.typecons;
import std.bitmanip;
static import core.stdc.config;
alias c_ulong = Typedef!(core.stdc.config.c_ulong);
static struct Foo
{
mixin(bitfields!(
c_ulong, "NameOffset", 31,
c_ulong, "NameIsString", 1
));
}
}
// https://issues.dlang.org/show_bug.cgi?id=12596
@safe unittest
{
import std.typecons;
alias TD = Typedef!int;
TD x = TD(1);
TD y = TD(x);
assert(x == y);
}
@safe unittest // about toHash
{
import std.typecons;
{
alias TD = Typedef!int;
int[TD] td;
td[TD(1)] = 1;
assert(td[TD(1)] == 1);
}
{
alias TD = Typedef!(int[]);
int[TD] td;
td[TD([1,2,3,4])] = 2;
assert(td[TD([1,2,3,4])] == 2);
}
{
alias TD = Typedef!(int[][]);
int[TD] td;
td[TD([[1,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]])] = 3;
assert(td[TD([[1,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]])] == 3);
}
{
struct MyStruct{ int x; }
alias TD = Typedef!MyStruct;
int[TD] td;
td[TD(MyStruct(10))] = 4;
assert(TD(MyStruct(20)) !in td);
assert(td[TD(MyStruct(10))] == 4);
}
{
static struct MyStruct2
{
int x;
size_t toHash() const nothrow @safe { return x; }
bool opEquals(ref const MyStruct2 r) const { return r.x == x; }
}
alias TD = Typedef!MyStruct2;
int[TD] td;
td[TD(MyStruct2(50))] = 5;
assert(td[TD(MyStruct2(50))] == 5);
}
{
class MyClass{}
alias TD = Typedef!MyClass;
int[TD] td;
auto c = new MyClass;
td[TD(c)] = 6;
assert(TD(new MyClass) !in td);
assert(td[TD(c)] == 6);
}
}
@system unittest
{
alias String = Typedef!(char[]);
alias CString = Typedef!(const(char)[]);
CString cs = "fubar";
String s = cast(String) cs;
assert(cs == s);
char[] s2 = cast(char[]) cs;
const(char)[] cs2 = cast(const(char)[])s;
assert(s2 == cs2);
}
@system unittest // toString
{
import std.meta : AliasSeq;
import std.conv : to;
struct TestS {}
class TestC {}
static foreach (T; AliasSeq!(int, bool, float, double, real,
char, dchar, wchar,
TestS, TestC,
int*, int[], int[2], int[int]))
{{
T t;
Typedef!T td;
Typedef!(const T) ctd;
Typedef!(immutable T) itd;
assert(t.to!string() == td.to!string());
static if (!(is(T == TestS) || is(T == TestC)))
{
assert(t.to!string() == ctd.to!string());
assert(t.to!string() == itd.to!string());
}
}}
}
@safe @nogc unittest // typedef'ed type with custom operators
{
static struct MyInt
{
int value;
int opCmp(MyInt other)
{
if (value < other.value)
return -1;
return !(value == other.value);
}
}
auto m1 = Typedef!MyInt(MyInt(1));
auto m2 = Typedef!MyInt(MyInt(2));
assert(m1 < m2);
}
/**
Allocates a `class` object right inside the current scope,
therefore avoiding the overhead of `new`. This facility is unsafe;
it is the responsibility of the user to not escape a reference to the
object outside the scope.
The class destructor will be called when the result of `scoped()` is
itself destroyed.
Scoped class instances can be embedded in a parent `class` or `struct`,
just like a child struct instance. Scoped member variables must have
type `typeof(scoped!Class(args))`, and be initialized with a call to
scoped. See below for an example.
Note:
It's illegal to move a class instance even if you are sure there
are no pointers to it. As such, it is illegal to move a scoped object.
*/
template scoped(T)
if (is(T == class))
{
// _d_newclass now use default GC alignment (looks like (void*).sizeof * 2 for
// small objects). We will just use the maximum of filed alignments.
alias alignment = classInstanceAlignment!T;
alias aligned = _alignUp!alignment;
static struct Scoped
{
// Addition of `alignment` is required as `Scoped_store` can be misaligned in memory.
private void[aligned(__traits(classInstanceSize, T) + size_t.sizeof) + alignment] Scoped_store = void;
@property inout(T) Scoped_payload() inout
{
void* alignedStore = cast(void*) aligned(cast(size_t) Scoped_store.ptr);
// As `Scoped` can be unaligned moved in memory class instance should be moved accordingly.
immutable size_t d = alignedStore - Scoped_store.ptr;
size_t* currD = cast(size_t*) &Scoped_store[$ - size_t.sizeof];
if (d != *currD)
{
import core.stdc.string : memmove;
memmove(alignedStore, Scoped_store.ptr + *currD, __traits(classInstanceSize, T));
*currD = d;
}
return cast(inout(T)) alignedStore;
}
alias Scoped_payload this;
@disable this();
@disable this(this);
~this()
{
// `destroy` will also write .init but we have no functions in druntime
// for deterministic finalization and memory releasing for now.
.destroy(Scoped_payload);
}
}
/** Returns the _scoped object.
Params: args = Arguments to pass to `T`'s constructor.
*/
@system auto scoped(Args...)(auto ref Args args)
{
import core.lifetime : emplace, forward;
Scoped result = void;
void* alignedStore = cast(void*) aligned(cast(size_t) result.Scoped_store.ptr);
immutable size_t d = alignedStore - result.Scoped_store.ptr;
*cast(size_t*) &result.Scoped_store[$ - size_t.sizeof] = d;
emplace!(Unqual!T)(result.Scoped_store[d .. $ - size_t.sizeof], forward!args);
return result;
}
}
///
@system unittest
{
class A
{
int x;
this() {x = 0;}
this(int i){x = i;}
~this() {}
}
// Standard usage, constructing A on the stack
auto a1 = scoped!A();
a1.x = 42;
// Result of `scoped` call implicitly converts to a class reference
A aRef = a1;
assert(aRef.x == 42);
// Scoped destruction
{
auto a2 = scoped!A(1);
assert(a2.x == 1);
aRef = a2;
// a2 is destroyed here, calling A's destructor
}
// aRef is now an invalid reference
// Here the temporary scoped A is immediately destroyed.
// This means the reference is then invalid.
version (Bug)
{
// Wrong, should use `auto`
A invalid = scoped!A();
}
// Restrictions
version (Bug)
{
import std.algorithm.mutation : move;
auto invalid = a1.move; // illegal, scoped objects can't be moved
}
static assert(!is(typeof({
auto e1 = a1; // illegal, scoped objects can't be copied
assert([a1][0].x == 42); // ditto
})));
static assert(!is(typeof({
alias ScopedObject = typeof(a1);
auto e2 = ScopedObject(); // illegal, must be built via scoped!A
auto e3 = ScopedObject(1); // ditto
})));
// Use with alias
alias makeScopedA = scoped!A;
auto a3 = makeScopedA();
auto a4 = makeScopedA(1);
// Use as member variable
struct B
{
typeof(scoped!A()) a; // note the trailing parentheses
this(int i)
{
// construct member
a = scoped!A(i);
}
}
// Stack-allocate
auto b1 = B(5);
aRef = b1.a;
assert(aRef.x == 5);
destroy(b1); // calls A's destructor for b1.a
// aRef is now an invalid reference
// Heap-allocate
auto b2 = new B(6);
assert(b2.a.x == 6);
destroy(*b2); // calls A's destructor for b2.a
}
private size_t _alignUp(size_t alignment)(size_t n)
if (alignment > 0 && !((alignment - 1) & alignment))
{
enum badEnd = alignment - 1; // 0b11, 0b111, ...
return (n + badEnd) & ~badEnd;
}
// https://issues.dlang.org/show_bug.cgi?id=6580 testcase
@system unittest
{
enum alignment = (void*).alignof;
static class C0 { }
static class C1 { byte b; }
static class C2 { byte[2] b; }
static class C3 { byte[3] b; }
static class C7 { byte[7] b; }
static assert(scoped!C0().sizeof % alignment == 0);
static assert(scoped!C1().sizeof % alignment == 0);
static assert(scoped!C2().sizeof % alignment == 0);
static assert(scoped!C3().sizeof % alignment == 0);
static assert(scoped!C7().sizeof % alignment == 0);
enum longAlignment = long.alignof;
static class C1long
{
long long_; byte byte_ = 4;
this() { }
this(long _long, ref int i) { long_ = _long; ++i; }
}
static class C2long { byte[2] byte_ = [5, 6]; long long_ = 7; }
static assert(scoped!C1long().sizeof % longAlignment == 0);
static assert(scoped!C2long().sizeof % longAlignment == 0);
void alignmentTest()
{
int var = 5;
auto c1long = scoped!C1long(3, var);
assert(var == 6);
auto c2long = scoped!C2long();
assert(cast(uint)&c1long.long_ % longAlignment == 0);
assert(cast(uint)&c2long.long_ % longAlignment == 0);
assert(c1long.long_ == 3 && c1long.byte_ == 4);
assert(c2long.byte_ == [5, 6] && c2long.long_ == 7);
}
alignmentTest();
version (DigitalMars)
{
void test(size_t size)
{
import core.stdc.stdlib;
alloca(size);
alignmentTest();
}
foreach (i; 0 .. 10)
test(i);
}
else
{
void test(size_t size)()
{
byte[size] arr;
alignmentTest();
}
static foreach (i; 0 .. 11)
test!i();
}
}
// Original https://issues.dlang.org/show_bug.cgi?id=6580 testcase
@system unittest
{
class C { int i; byte b; }
auto sa = [scoped!C(), scoped!C()];
assert(cast(uint)&sa[0].i % int.alignof == 0);
assert(cast(uint)&sa[1].i % int.alignof == 0); // fails
}
@system unittest
{
class A { int x = 1; }
auto a1 = scoped!A();
assert(a1.x == 1);
auto a2 = scoped!A();
a1.x = 42;
a2.x = 53;
assert(a1.x == 42);
}
@system unittest
{
class A { int x = 1; this() { x = 2; } }
auto a1 = scoped!A();
assert(a1.x == 2);
auto a2 = scoped!A();
a1.x = 42;
a2.x = 53;
assert(a1.x == 42);
}
@system unittest
{
class A { int x = 1; this(int y) { x = y; } ~this() {} }
auto a1 = scoped!A(5);
assert(a1.x == 5);
auto a2 = scoped!A(42);
a1.x = 42;
a2.x = 53;
assert(a1.x == 42);
}
@system unittest
{
class A { static bool dead; ~this() { dead = true; } }
class B : A { static bool dead; ~this() { dead = true; } }
{
auto b = scoped!B();
}
assert(B.dead, "asdasd");
assert(A.dead, "asdasd");
}
// https://issues.dlang.org/show_bug.cgi?id=8039 testcase
@system unittest
{
static int dels;
static struct S { ~this(){ ++dels; } }
static class A { S s; }
dels = 0; { scoped!A(); }
assert(dels == 1);
static class B { S[2] s; }
dels = 0; { scoped!B(); }
assert(dels == 2);
static struct S2 { S[3] s; }
static class C { S2[2] s; }
dels = 0; { scoped!C(); }
assert(dels == 6);
static class D: A { S2[2] s; }
dels = 0; { scoped!D(); }
assert(dels == 1+6);
}
@system unittest
{
// https://issues.dlang.org/show_bug.cgi?id=4500
class A
{
this() { a = this; }
this(int i) { a = this; }
A a;
bool check() { return this is a; }
}
auto a1 = scoped!A();
assert(a1.check());
auto a2 = scoped!A(1);
assert(a2.check());
a1.a = a1;
assert(a1.check());
}
@system unittest
{
static class A
{
static int sdtor;
this() { ++sdtor; assert(sdtor == 1); }
~this() { assert(sdtor == 1); --sdtor; }
}
interface Bob {}
static class ABob : A, Bob
{
this() { ++sdtor; assert(sdtor == 2); }
~this() { assert(sdtor == 2); --sdtor; }
}
A.sdtor = 0;
scope(exit) assert(A.sdtor == 0);
auto abob = scoped!ABob();
}
@safe unittest
{
static class A { this(int) {} }
static assert(!__traits(compiles, scoped!A()));
}
@system unittest
{
static class A { @property inout(int) foo() inout { return 1; } }
auto a1 = scoped!A();
assert(a1.foo == 1);
static assert(is(typeof(a1.foo) == int));
auto a2 = scoped!(const(A))();
assert(a2.foo == 1);
static assert(is(typeof(a2.foo) == const(int)));
auto a3 = scoped!(immutable(A))();
assert(a3.foo == 1);
static assert(is(typeof(a3.foo) == immutable(int)));
const c1 = scoped!A();
assert(c1.foo == 1);
static assert(is(typeof(c1.foo) == const(int)));
const c2 = scoped!(const(A))();
assert(c2.foo == 1);
static assert(is(typeof(c2.foo) == const(int)));
const c3 = scoped!(immutable(A))();
assert(c3.foo == 1);
static assert(is(typeof(c3.foo) == immutable(int)));
}
@system unittest
{
class C
{
this(int rval) { assert(rval == 1); }
this(ref int lval) { assert(lval == 3); ++lval; }
}
auto c1 = scoped!C(1);
int lval = 3;
auto c2 = scoped!C(lval);
assert(lval == 4);
}
@system unittest
{
class C
{
this(){}
this(int){}
this(int, int){}
}
alias makeScopedC = scoped!C;
auto a = makeScopedC();
auto b = makeScopedC(1);
auto c = makeScopedC(1, 1);
static assert(is(typeof(a) == typeof(b)));
static assert(is(typeof(b) == typeof(c)));
}
/**
Defines a simple, self-documenting yes/no flag. This makes it easy for
APIs to define functions accepting flags without resorting to $(D
bool), which is opaque in calls, and without needing to define an
enumerated type separately. Using `Flag!"Name"` instead of $(D
bool) makes the flag's meaning visible in calls. Each yes/no flag has
its own type, which makes confusions and mix-ups impossible.
Example:
Code calling `getLine` (usually far away from its definition) can't be
understood without looking at the documentation, even by users familiar with
the API:
----
string getLine(bool keepTerminator)
{
...
if (keepTerminator) ...
...
}
...
auto line = getLine(false);
----
Assuming the reverse meaning (i.e. "ignoreTerminator") and inserting the wrong
code compiles and runs with erroneous results.
After replacing the boolean parameter with an instantiation of `Flag`, code
calling `getLine` can be easily read and understood even by people not
fluent with the API:
----
string getLine(Flag!"keepTerminator" keepTerminator)
{
...
if (keepTerminator) ...
...
}
...
auto line = getLine(Yes.keepTerminator);
----
The structs `Yes` and `No` are provided as shorthand for
`Flag!"Name".yes` and `Flag!"Name".no` and are preferred for brevity and
readability. These convenience structs mean it is usually unnecessary and
counterproductive to create an alias of a `Flag` as a way of avoiding typing
out the full type while specifying the affirmative or negative options.
Passing categorical data by means of unstructured `bool`
parameters is classified under "simple-data coupling" by Steve
McConnell in the $(LUCKY Code Complete) book, along with three other
kinds of coupling. The author argues citing several studies that
coupling has a negative effect on code quality. `Flag` offers a
simple structuring method for passing yes/no flags to APIs.
*/
template Flag(string name) {
///
enum Flag : bool
{
/**
When creating a value of type `Flag!"Name"`, use $(D
Flag!"Name".no) for the negative option. When using a value
of type `Flag!"Name"`, compare it against $(D
Flag!"Name".no) or just `false` or `0`. */
no = false,
/** When creating a value of type `Flag!"Name"`, use $(D
Flag!"Name".yes) for the affirmative option. When using a
value of type `Flag!"Name"`, compare it against $(D
Flag!"Name".yes).
*/
yes = true
}
}
///
@safe unittest
{
Flag!"abc" flag;
assert(flag == Flag!"abc".no);
assert(flag == No.abc);
assert(!flag);
if (flag) assert(0);
}
///
@safe unittest
{
auto flag = Yes.abc;
assert(flag);
assert(flag == Yes.abc);
if (!flag) assert(0);
if (flag) {} else assert(0);
}
/**
Convenience names that allow using e.g. `Yes.encryption` instead of
`Flag!"encryption".yes` and `No.encryption` instead of $(D
Flag!"encryption".no).
*/
struct Yes
{
template opDispatch(string name)
{
enum opDispatch = Flag!name.yes;
}
}
//template yes(string name) { enum Flag!name yes = Flag!name.yes; }
/// Ditto
struct No
{
template opDispatch(string name)
{
enum opDispatch = Flag!name.no;
}
}
///
@safe unittest
{
Flag!"abc" flag;
assert(flag == Flag!"abc".no);
assert(flag == No.abc);
assert(!flag);
if (flag) assert(0);
}
///
@safe unittest
{
auto flag = Yes.abc;
assert(flag);
assert(flag == Yes.abc);
if (!flag) assert(0);
if (flag) {} else assert(0);
}
/**
Detect whether an enum is of integral type and has only "flag" values
(i.e. values with a bit count of exactly 1).
Additionally, a zero value is allowed for compatibility with enums including
a "None" value.
*/
template isBitFlagEnum(E)
{
static if (is(E Base == enum) && isIntegral!Base)
{
enum isBitFlagEnum = (E.min >= 0) &&
{
static foreach (immutable flag; EnumMembers!E)
{{
Base value = flag;
value &= value - 1;
if (value != 0) return false;
}}
return true;
}();
}
else
{
enum isBitFlagEnum = false;
}
}
///
@safe pure nothrow unittest
{
enum A
{
None,
A = 1 << 0,
B = 1 << 1,
C = 1 << 2,
D = 1 << 3,
}
static assert(isBitFlagEnum!A);
}
/// Test an enum with default (consecutive) values
@safe pure nothrow unittest
{
enum B
{
A,
B,
C,
D // D == 3
}
static assert(!isBitFlagEnum!B);
}
/// Test an enum with non-integral values
@safe pure nothrow unittest
{
enum C: double
{
A = 1 << 0,
B = 1 << 1
}
static assert(!isBitFlagEnum!C);
}
/**
A typesafe structure for storing combinations of enum values.
This template defines a simple struct to represent bitwise OR combinations of
enum values. It can be used if all the enum values are integral constants with
a bit count of at most 1, or if the `unsafe` parameter is explicitly set to
Yes.
This is much safer than using the enum itself to store
the OR combination, which can produce surprising effects like this:
----
enum E
{
A = 1 << 0,
B = 1 << 1
}
E e = E.A | E.B;
// will throw SwitchError
final switch (e)
{
case E.A:
return;
case E.B:
return;
}
----
*/
struct BitFlags(E, Flag!"unsafe" unsafe = No.unsafe)
if (unsafe || isBitFlagEnum!(E))
{
@safe @nogc pure nothrow:
private:
enum isBaseEnumType(T) = is(E == T);
alias Base = OriginalType!E;
Base mValue;
static struct Negation
{
@safe @nogc pure nothrow:
private:
Base mValue;
// Prevent non-copy construction outside the module.
@disable this();
this(Base value)
{
mValue = value;
}
}
public:
this(E flag)
{
this = flag;
}
this(T...)(T flags)
if (allSatisfy!(isBaseEnumType, T))
{
this = flags;
}
bool opCast(B: bool)() const
{
return mValue != 0;
}
Base opCast(B)() const
if (isImplicitlyConvertible!(Base, B))
{
return mValue;
}
Negation opUnary(string op)() const
if (op == "~")
{
return Negation(~mValue);
}
auto ref opAssign(T...)(T flags)
if (allSatisfy!(isBaseEnumType, T))
{
mValue = 0;
foreach (E flag; flags)
{
mValue |= flag;
}
return this;
}
auto ref opAssign(E flag)
{
mValue = flag;
return this;
}
auto ref opOpAssign(string op: "|")(BitFlags flags)
{
mValue |= flags.mValue;
return this;
}
auto ref opOpAssign(string op: "&")(BitFlags flags)
{
mValue &= flags.mValue;
return this;
}
auto ref opOpAssign(string op: "|")(E flag)
{
mValue |= flag;
return this;
}
auto ref opOpAssign(string op: "&")(E flag)
{
mValue &= flag;
return this;
}
auto ref opOpAssign(string op: "&")(Negation negatedFlags)
{
mValue &= negatedFlags.mValue;
return this;
}
auto opBinary(string op)(BitFlags flags) const
if (op == "|" || op == "&")
{
BitFlags result = this;
result.opOpAssign!op(flags);
return result;
}
auto opBinary(string op)(E flag) const
if (op == "|" || op == "&")
{
BitFlags result = this;
result.opOpAssign!op(flag);
return result;
}
auto opBinary(string op: "&")(Negation negatedFlags) const
{
BitFlags result = this;
result.opOpAssign!op(negatedFlags);
return result;
}
auto opBinaryRight(string op)(E flag) const
if (op == "|" || op == "&")
{
return opBinary!op(flag);
}
bool opDispatch(string name)() const
if (__traits(hasMember, E, name))
{
enum e = __traits(getMember, E, name);
return (mValue & e) == e;
}
void opDispatch(string name)(bool set)
if (__traits(hasMember, E, name))
{
enum e = __traits(getMember, E, name);
if (set)
mValue |= e;
else
mValue &= ~e;
}
}
/// Set values with the | operator and test with &
@safe @nogc pure nothrow unittest
{
enum Enum
{
A = 1 << 0,
}
// A default constructed BitFlags has no value set
immutable BitFlags!Enum flags_empty;
assert(!flags_empty.A);
// Value can be set with the | operator
immutable flags_A = flags_empty | Enum.A;
// and tested using property access
assert(flags_A.A);
// or the & operator
assert(flags_A & Enum.A);
// which commutes.
assert(Enum.A & flags_A);
}
/// A default constructed BitFlags has no value set
@safe @nogc pure nothrow unittest
{
enum Enum
{
None,
A = 1 << 0,
B = 1 << 1,
C = 1 << 2
}
immutable BitFlags!Enum flags_empty;
assert(!(flags_empty & (Enum.A | Enum.B | Enum.C)));
assert(!(flags_empty & Enum.A) && !(flags_empty & Enum.B) && !(flags_empty & Enum.C));
}
// BitFlags can be variadically initialized
@safe @nogc pure nothrow unittest
{
import std.traits : EnumMembers;
enum Enum
{
A = 1 << 0,
B = 1 << 1,
C = 1 << 2
}
// Values can also be set using property access
BitFlags!Enum flags;
flags.A = true;
assert(flags & Enum.A);
flags.A = false;
assert(!(flags & Enum.A));
// BitFlags can be variadically initialized
immutable BitFlags!Enum flags_AB = BitFlags!Enum(Enum.A, Enum.B);
assert(flags_AB.A && flags_AB.B && !flags_AB.C);
// You can use the EnumMembers template to set all flags
immutable BitFlags!Enum flags_all = EnumMembers!Enum;
assert(flags_all.A && flags_all.B && flags_all.C);
}
/// Binary operations: subtracting and intersecting flags
@safe @nogc pure nothrow unittest
{
enum Enum
{
A = 1 << 0,
B = 1 << 1,
C = 1 << 2,
}
immutable BitFlags!Enum flags_AB = BitFlags!Enum(Enum.A, Enum.B);
immutable BitFlags!Enum flags_BC = BitFlags!Enum(Enum.B, Enum.C);
// Use the ~ operator for subtracting flags
immutable BitFlags!Enum flags_B = flags_AB & ~BitFlags!Enum(Enum.A);
assert(!flags_B.A && flags_B.B && !flags_B.C);
// use & between BitFlags for intersection
assert(flags_B == (flags_BC & flags_AB));
}
/// All the binary operators work in their assignment version
@safe @nogc pure nothrow unittest
{
enum Enum
{
A = 1 << 0,
B = 1 << 1,
}
BitFlags!Enum flags_empty, temp, flags_AB;
flags_AB = Enum.A | Enum.B;
temp |= flags_AB;
assert(temp == (flags_empty | flags_AB));
temp = flags_empty;
temp |= Enum.B;
assert(temp == (flags_empty | Enum.B));
temp = flags_empty;
temp &= flags_AB;
assert(temp == (flags_empty & flags_AB));
temp = flags_empty;
temp &= Enum.A;
assert(temp == (flags_empty & Enum.A));
}
/// Conversion to bool and int
@safe @nogc pure nothrow unittest
{
enum Enum
{
A = 1 << 0,
B = 1 << 1,
}
BitFlags!Enum flags;
// BitFlags with no value set evaluate to false
assert(!flags);
// BitFlags with at least one value set evaluate to true
flags |= Enum.A;
assert(flags);
// This can be useful to check intersection between BitFlags
BitFlags!Enum flags_AB = Enum.A | Enum.B;
assert(flags & flags_AB);
assert(flags & Enum.A);
// You can of course get you raw value out of flags
auto value = cast(int) flags;
assert(value == Enum.A);
}
/// You need to specify the `unsafe` parameter for enums with custom values
@safe @nogc pure nothrow unittest
{
enum UnsafeEnum
{
A = 1,
B = 2,
C = 4,
BC = B|C
}
static assert(!__traits(compiles, { BitFlags!UnsafeEnum flags; }));
BitFlags!(UnsafeEnum, Yes.unsafe) flags;
// property access tests for exact match of unsafe enums
flags.B = true;
assert(!flags.BC); // only B
flags.C = true;
assert(flags.BC); // both B and C
flags.B = false;
assert(!flags.BC); // only C
// property access sets all bits of unsafe enum group
flags = flags.init;
flags.BC = true;
assert(!flags.A && flags.B && flags.C);
flags.A = true;
flags.BC = false;
assert(flags.A && !flags.B && !flags.C);
}
private enum false_(T) = false;
// ReplaceType
/**
Replaces all occurrences of `From` into `To`, in one or more types `T`. For
example, `ReplaceType!(int, uint, Tuple!(int, float)[string])` yields
`Tuple!(uint, float)[string]`. The types in which replacement is performed
may be arbitrarily complex, including qualifiers, built-in type constructors
(pointers, arrays, associative arrays, functions, and delegates), and template
instantiations; replacement proceeds transitively through the type definition.
However, member types in `struct`s or `class`es are not replaced because there
are no ways to express the types resulting after replacement.
This is an advanced type manipulation necessary e.g. for replacing the
placeholder type `This` in $(REF Algebraic, std,variant).
Returns: `ReplaceType` aliases itself to the type(s) that result after
replacement.
*/
alias ReplaceType(From, To, T...) = ReplaceTypeUnless!(false_, From, To, T);
///
@safe unittest
{
static assert(
is(ReplaceType!(int, string, int[]) == string[]) &&
is(ReplaceType!(int, string, int[int]) == string[string]) &&
is(ReplaceType!(int, string, const(int)[]) == const(string)[]) &&
is(ReplaceType!(int, string, Tuple!(int[], float))
== Tuple!(string[], float))
);
}
/**
Like $(LREF ReplaceType), but does not perform replacement in types for which
`pred` evaluates to `true`.
*/
template ReplaceTypeUnless(alias pred, From, To, T...)
{
import std.meta;
static if (T.length == 1)
{
static if (pred!(T[0]))
alias ReplaceTypeUnless = T[0];
else static if (is(T[0] == From))
alias ReplaceTypeUnless = To;
else static if (is(T[0] == const(U), U))
alias ReplaceTypeUnless = const(ReplaceTypeUnless!(pred, From, To, U));
else static if (is(T[0] == immutable(U), U))
alias ReplaceTypeUnless = immutable(ReplaceTypeUnless!(pred, From, To, U));
else static if (is(T[0] == shared(U), U))
alias ReplaceTypeUnless = shared(ReplaceTypeUnless!(pred, From, To, U));
else static if (is(T[0] == U*, U))
{
static if (is(U == function))
alias ReplaceTypeUnless = replaceTypeInFunctionTypeUnless!(pred, From, To, T[0]);
else
alias ReplaceTypeUnless = ReplaceTypeUnless!(pred, From, To, U)*;
}
else static if (is(T[0] == delegate))
{
alias ReplaceTypeUnless = replaceTypeInFunctionTypeUnless!(pred, From, To, T[0]);
}
else static if (is(T[0] == function))
{
static assert(0, "Function types not supported," ~
" use a function pointer type instead of " ~ T[0].stringof);
}
else static if (is(T[0] == U!V, alias U, V...))
{
template replaceTemplateArgs(T...)
{
static if (is(typeof(T[0]))) // template argument is value or symbol
enum replaceTemplateArgs = T[0];
else
alias replaceTemplateArgs = ReplaceTypeUnless!(pred, From, To, T[0]);
}
alias ReplaceTypeUnless = U!(staticMap!(replaceTemplateArgs, V));
}
else static if (is(T[0] == struct))
// don't match with alias this struct below
// https://issues.dlang.org/show_bug.cgi?id=15168
alias ReplaceTypeUnless = T[0];
else static if (is(T[0] == U[], U))
alias ReplaceTypeUnless = ReplaceTypeUnless!(pred, From, To, U)[];
else static if (is(T[0] == U[n], U, size_t n))
alias ReplaceTypeUnless = ReplaceTypeUnless!(pred, From, To, U)[n];
else static if (is(T[0] == U[V], U, V))
alias ReplaceTypeUnless =
ReplaceTypeUnless!(pred, From, To, U)[ReplaceTypeUnless!(pred, From, To, V)];
else
alias ReplaceTypeUnless = T[0];
}
else static if (T.length > 1)
{
alias ReplaceTypeUnless = AliasSeq!(ReplaceTypeUnless!(pred, From, To, T[0]),
ReplaceTypeUnless!(pred, From, To, T[1 .. $]));
}
else
{
alias ReplaceTypeUnless = AliasSeq!();
}
}
///
@safe unittest
{
import std.traits : isArray;
static assert(
is(ReplaceTypeUnless!(isArray, int, string, int*) == string*) &&
is(ReplaceTypeUnless!(isArray, int, string, int[]) == int[]) &&
is(ReplaceTypeUnless!(isArray, int, string, Tuple!(int, int[]))
== Tuple!(string, int[]))
);
}
private template replaceTypeInFunctionTypeUnless(alias pred, From, To, fun)
{
alias RX = ReplaceTypeUnless!(pred, From, To, ReturnType!fun);
alias PX = AliasSeq!(ReplaceTypeUnless!(pred, From, To, Parameters!fun));
// Wrapping with AliasSeq is neccesary because ReplaceType doesn't return
// tuple if Parameters!fun.length == 1
string gen()
{
enum linkage = functionLinkage!fun;
alias attributes = functionAttributes!fun;
enum variadicStyle = variadicFunctionStyle!fun;
alias storageClasses = ParameterStorageClassTuple!fun;
string result;
result ~= "extern(" ~ linkage ~ ") ";
static if (attributes & FunctionAttribute.ref_)
{
result ~= "ref ";
}
result ~= "RX";
static if (is(fun == delegate))
result ~= " delegate";
else
result ~= " function";
result ~= "(";
static foreach (i; 0 .. PX.length)
{
if (i)
result ~= ", ";
if (storageClasses[i] & ParameterStorageClass.scope_)
result ~= "scope ";
if (storageClasses[i] & ParameterStorageClass.out_)
result ~= "out ";
if (storageClasses[i] & ParameterStorageClass.ref_)
result ~= "ref ";
if (storageClasses[i] & ParameterStorageClass.lazy_)
result ~= "lazy ";
if (storageClasses[i] & ParameterStorageClass.return_)
result ~= "return ";
result ~= "PX[" ~ i.stringof ~ "]";
}
static if (variadicStyle == Variadic.typesafe)
result ~= " ...";
else static if (variadicStyle != Variadic.no)
result ~= ", ...";
result ~= ")";
static if (attributes & FunctionAttribute.pure_)
result ~= " pure";
static if (attributes & FunctionAttribute.nothrow_)
result ~= " nothrow";
static if (attributes & FunctionAttribute.property)
result ~= " @property";
static if (attributes & FunctionAttribute.trusted)
result ~= " @trusted";
static if (attributes & FunctionAttribute.safe)
result ~= " @safe";
static if (attributes & FunctionAttribute.nogc)
result ~= " @nogc";
static if (attributes & FunctionAttribute.system)
result ~= " @system";
static if (attributes & FunctionAttribute.const_)
result ~= " const";
static if (attributes & FunctionAttribute.immutable_)
result ~= " immutable";
static if (attributes & FunctionAttribute.inout_)
result ~= " inout";
static if (attributes & FunctionAttribute.shared_)
result ~= " shared";
static if (attributes & FunctionAttribute.return_)
result ~= " return";
return result;
}
mixin("alias replaceTypeInFunctionTypeUnless = " ~ gen() ~ ";");
}
@safe unittest
{
template Test(Ts...)
{
static if (Ts.length)
{
//pragma(msg, "Testing: ReplaceType!("~Ts[0].stringof~", "
// ~Ts[1].stringof~", "~Ts[2].stringof~")");
static assert(is(ReplaceType!(Ts[0], Ts[1], Ts[2]) == Ts[3]),
"ReplaceType!("~Ts[0].stringof~", "~Ts[1].stringof~", "
~Ts[2].stringof~") == "
~ReplaceType!(Ts[0], Ts[1], Ts[2]).stringof);
alias Test = Test!(Ts[4 .. $]);
}
else alias Test = void;
}
//import core.stdc.stdio;
alias RefFun1 = ref int function(float, long);
alias RefFun2 = ref float function(float, long);
extern(C) int printf(const char*, ...) nothrow @nogc @system;
extern(C) float floatPrintf(const char*, ...) nothrow @nogc @system;
int func(float);
int x;
struct S1 { void foo() { x = 1; } }
struct S2 { void bar() { x = 2; } }
alias Pass = Test!(
int, float, typeof(&func), float delegate(float),
int, float, typeof(&printf), typeof(&floatPrintf),
int, float, int function(out long, ...),
float function(out long, ...),
int, float, int function(ref float, long),
float function(ref float, long),
int, float, int function(ref int, long),
float function(ref float, long),
int, float, int function(out int, long),
float function(out float, long),
int, float, int function(lazy int, long),
float function(lazy float, long),
int, float, int function(out long, ref const int),
float function(out long, ref const float),
int, int, int, int,
int, float, int, float,
int, float, const int, const float,
int, float, immutable int, immutable float,
int, float, shared int, shared float,
int, float, int*, float*,
int, float, const(int)*, const(float)*,
int, float, const(int*), const(float*),
const(int)*, float, const(int*), const(float),
int*, float, const(int)*, const(int)*,
int, float, int[], float[],
int, float, int[42], float[42],
int, float, const(int)[42], const(float)[42],
int, float, const(int[42]), const(float[42]),
int, float, int[int], float[float],
int, float, int[double], float[double],
int, float, double[int], double[float],
int, float, int function(float, long), float function(float, long),
int, float, int function(float), float function(float),
int, float, int function(float, int), float function(float, float),
int, float, int delegate(float, long), float delegate(float, long),
int, float, int delegate(float), float delegate(float),
int, float, int delegate(float, int), float delegate(float, float),
int, float, Unique!int, Unique!float,
int, float, Tuple!(float, int), Tuple!(float, float),
int, float, RefFun1, RefFun2,
S1, S2,
S1[1][][S1]* function(),
S2[1][][S2]* function(),
int, string,
int[3] function( int[] arr, int[2] ...) pure @trusted,
string[3] function(string[] arr, string[2] ...) pure @trusted,
);
// https://issues.dlang.org/show_bug.cgi?id=15168
static struct T1 { string s; alias s this; }
static struct T2 { char[10] s; alias s this; }
static struct T3 { string[string] s; alias s this; }
alias Pass2 = Test!(
ubyte, ubyte, T1, T1,
ubyte, ubyte, T2, T2,
ubyte, ubyte, T3, T3,
);
}
// https://issues.dlang.org/show_bug.cgi?id=17116
@safe unittest
{
alias ConstDg = void delegate(float) const;
alias B = void delegate(int) const;
alias A = ReplaceType!(float, int, ConstDg);
static assert(is(B == A));
}
// https://issues.dlang.org/show_bug.cgi?id=19696
@safe unittest
{
static struct T(U) {}
static struct S { T!int t; alias t this; }
static assert(is(ReplaceType!(float, float, S) == S));
}
// https://issues.dlang.org/show_bug.cgi?id=19697
@safe unittest
{
class D(T) {}
class C : D!C {}
static assert(is(ReplaceType!(float, float, C)));
}
// https://issues.dlang.org/show_bug.cgi?id=16132
@safe unittest
{
interface I(T) {}
class C : I!int {}
static assert(is(ReplaceType!(int, string, C) == C));
}
/**
Ternary type with three truth values:
$(UL
$(LI `Ternary.yes` for `true`)
$(LI `Ternary.no` for `false`)
$(LI `Ternary.unknown` as an unknown state)
)
Also known as trinary, trivalent, or trilean.
See_Also:
$(HTTP en.wikipedia.org/wiki/Three-valued_logic,
Three Valued Logic on Wikipedia)
*/
struct Ternary
{
@safe @nogc nothrow pure:
private ubyte value = 6;
private static Ternary make(ubyte b)
{
Ternary r = void;
r.value = b;
return r;
}
/**
The possible states of the `Ternary`
*/
enum no = make(0);
/// ditto
enum yes = make(2);
/// ditto
enum unknown = make(6);
/**
Construct and assign from a `bool`, receiving `no` for `false` and `yes`
for `true`.
*/
this(bool b) { value = b << 1; }
/// ditto
void opAssign(bool b) { value = b << 1; }
/**
Construct a ternary value from another ternary value
*/
this(const Ternary b) { value = b.value; }
/**
$(TABLE Truth table for logical operations,
$(TR $(TH `a`) $(TH `b`) $(TH `$(TILDE)a`) $(TH `a | b`) $(TH `a & b`) $(TH `a ^ b`))
$(TR $(TD `no`) $(TD `no`) $(TD `yes`) $(TD `no`) $(TD `no`) $(TD `no`))
$(TR $(TD `no`) $(TD `yes`) $(TD) $(TD `yes`) $(TD `no`) $(TD `yes`))
$(TR $(TD `no`) $(TD `unknown`) $(TD) $(TD `unknown`) $(TD `no`) $(TD `unknown`))
$(TR $(TD `yes`) $(TD `no`) $(TD `no`) $(TD `yes`) $(TD `no`) $(TD `yes`))
$(TR $(TD `yes`) $(TD `yes`) $(TD) $(TD `yes`) $(TD `yes`) $(TD `no`))
$(TR $(TD `yes`) $(TD `unknown`) $(TD) $(TD `yes`) $(TD `unknown`) $(TD `unknown`))
$(TR $(TD `unknown`) $(TD `no`) $(TD `unknown`) $(TD `unknown`) $(TD `no`) $(TD `unknown`))
$(TR $(TD `unknown`) $(TD `yes`) $(TD) $(TD `yes`) $(TD `unknown`) $(TD `unknown`))
$(TR $(TD `unknown`) $(TD `unknown`) $(TD) $(TD `unknown`) $(TD `unknown`) $(TD `unknown`))
)
*/
Ternary opUnary(string s)() if (s == "~")
{
return make((386 >> value) & 6);
}
/// ditto
Ternary opBinary(string s)(Ternary rhs) if (s == "|")
{
return make((25_512 >> (value + rhs.value)) & 6);
}
/// ditto
Ternary opBinary(string s)(Ternary rhs) if (s == "&")
{
return make((26_144 >> (value + rhs.value)) & 6);
}
/// ditto
Ternary opBinary(string s)(Ternary rhs) if (s == "^")
{
return make((26_504 >> (value + rhs.value)) & 6);
}
/// ditto
Ternary opBinary(string s)(bool rhs)
if (s == "|" || s == "&" || s == "^")
{
return this.opBinary!s(Ternary(rhs));
}
}
///
@safe @nogc nothrow pure
unittest
{
Ternary a;
assert(a == Ternary.unknown);
assert(~Ternary.yes == Ternary.no);
assert(~Ternary.no == Ternary.yes);
assert(~Ternary.unknown == Ternary.unknown);
}
@safe @nogc nothrow pure
unittest
{
alias f = Ternary.no, t = Ternary.yes, u = Ternary.unknown;
Ternary[27] truthTableAnd =
[
t, t, t,
t, u, u,
t, f, f,
u, t, u,
u, u, u,
u, f, f,
f, t, f,
f, u, f,
f, f, f,
];
Ternary[27] truthTableOr =
[
t, t, t,
t, u, t,
t, f, t,
u, t, t,
u, u, u,
u, f, u,
f, t, t,
f, u, u,
f, f, f,
];
Ternary[27] truthTableXor =
[
t, t, f,
t, u, u,
t, f, t,
u, t, u,
u, u, u,
u, f, u,
f, t, t,
f, u, u,
f, f, f,
];
for (auto i = 0; i != truthTableAnd.length; i += 3)
{
assert((truthTableAnd[i] & truthTableAnd[i + 1])
== truthTableAnd[i + 2]);
assert((truthTableOr[i] | truthTableOr[i + 1])
== truthTableOr[i + 2]);
assert((truthTableXor[i] ^ truthTableXor[i + 1])
== truthTableXor[i + 2]);
}
Ternary a;
assert(a == Ternary.unknown);
static assert(!is(typeof({ if (a) {} })));
assert(!is(typeof({ auto b = Ternary(3); })));
a = true;
assert(a == Ternary.yes);
a = false;
assert(a == Ternary.no);
a = Ternary.unknown;
assert(a == Ternary.unknown);
Ternary b;
b = a;
assert(b == a);
assert(~Ternary.yes == Ternary.no);
assert(~Ternary.no == Ternary.yes);
assert(~Ternary.unknown == Ternary.unknown);
}
@safe @nogc nothrow pure
unittest
{
Ternary a = Ternary(true);
assert(a == Ternary.yes);
assert((a & false) == Ternary.no);
assert((a | false) == Ternary.yes);
assert((a ^ true) == Ternary.no);
assert((a ^ false) == Ternary.yes);
}
|
D
|
a shed at the edge of a river or lake
|
D
|
module engine.core.window.context;
import engine.core.window.exceptions;
import derelict.glfw3.glfw3;
import derelict.opengl3.gl3;
import std.exception: enforce;
enum WindowContextVersion {
None = 0,
OpenGL_21 = 21,
OpenGL_32 = 31,
OpenGL_41 = 41,
OpenGL_45 = 45,
OpenGL_ES_20 = 120,
OpenGL_ES_30 = 130,
Vulkan = 50,
}
// ported from gsb
void configureWindowContextVersionHints (WindowContextVersion contextVersion) {
final switch (contextVersion) {
case WindowContextVersion.None: {
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
} break;
case WindowContextVersion.OpenGL_21: {
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, false);
} break;
case WindowContextVersion.OpenGL_32: {
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, false);
} break;
case WindowContextVersion.OpenGL_41: {
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, true);
} break;
case WindowContextVersion.OpenGL_45: {
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, true);
} break;
case WindowContextVersion.OpenGL_ES_20: {
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
} break;
case WindowContextVersion.OpenGL_ES_30: {
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
} break;
case WindowContextVersion.Vulkan: {
enforce!WindowCreationException(false, "vulkan not available");
//enforce!WindowCreationException(glfwVulkanAvailable(), "Failed to initialize GLFW window: Vulkan is not available");
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
} break;
}
}
|
D
|
/Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Console.build/Console.swift.o : /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Terminal/ANSI.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Deprecated.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Console.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleStyle.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Choose.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityIndicatorState.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Ask.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Terminal/Terminal.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Clear/Console+Ephemeral.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Confirm.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/LoadingBar.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ProgressBar.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityBar.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Clear/Console+Clear.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Clear/ConsoleClear.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Utilities/ConsoleLogger.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityIndicatorRenderer.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/Console+Center.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleColor.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Utilities/ConsoleError.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityIndicator.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Utilities/Exports.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/Console+Wait.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleTextFragment.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Input.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/Console+Output.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleText.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.apinotesc /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/NIO.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Async.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Service.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Core.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Logging.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Debugging.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/NIOConcurrencyHelpers.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Bits.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/NIOFoundationCompat.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/cpp_magic.h /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIODarwin/include/c_nio_darwin.h /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/c-atomics.h /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOLinux/include/c_nio_linux.h /Users/work/Projects/Hello/.build/checkouts/swift-nio-zlib-support.git--1071467962839356487/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOSHA1.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOOpenSSL.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOZlib.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIODarwin.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOHTTPParser.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOAtomics.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOLinux.build/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes
/Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Console.build/Console~partial.swiftmodule : /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Terminal/ANSI.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Deprecated.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Console.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleStyle.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Choose.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityIndicatorState.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Ask.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Terminal/Terminal.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Clear/Console+Ephemeral.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Confirm.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/LoadingBar.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ProgressBar.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityBar.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Clear/Console+Clear.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Clear/ConsoleClear.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Utilities/ConsoleLogger.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityIndicatorRenderer.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/Console+Center.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleColor.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Utilities/ConsoleError.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityIndicator.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Utilities/Exports.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/Console+Wait.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleTextFragment.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Input.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/Console+Output.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleText.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.apinotesc /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/NIO.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Async.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Service.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Core.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Logging.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Debugging.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/NIOConcurrencyHelpers.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Bits.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/NIOFoundationCompat.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/cpp_magic.h /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIODarwin/include/c_nio_darwin.h /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/c-atomics.h /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOLinux/include/c_nio_linux.h /Users/work/Projects/Hello/.build/checkouts/swift-nio-zlib-support.git--1071467962839356487/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOSHA1.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOOpenSSL.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOZlib.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIODarwin.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOHTTPParser.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOAtomics.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOLinux.build/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes
/Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Console.build/Console~partial.swiftdoc : /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Terminal/ANSI.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Deprecated.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Console.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleStyle.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Choose.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityIndicatorState.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Ask.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Terminal/Terminal.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Clear/Console+Ephemeral.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Confirm.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/LoadingBar.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ProgressBar.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityBar.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Clear/Console+Clear.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Clear/ConsoleClear.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Utilities/ConsoleLogger.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityIndicatorRenderer.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/Console+Center.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleColor.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Utilities/ConsoleError.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Activity/ActivityIndicator.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Utilities/Exports.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/Console+Wait.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleTextFragment.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Input/Console+Input.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/Console+Output.swift /Users/work/Projects/Hello/.build/checkouts/console.git--2431895819212044213/Sources/Console/Output/ConsoleText.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.apinotesc /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/ObjectiveC.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/NIO.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Async.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Service.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Core.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Logging.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Debugging.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Dispatch.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/CoreGraphics.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/NIOConcurrencyHelpers.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/Bits.swiftmodule /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/NIOFoundationCompat.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/IOKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/x86_64/SwiftOnoneSupport.swiftmodule /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/cpp_magic.h /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIODarwin/include/c_nio_darwin.h /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOAtomics/include/c-atomics.h /Users/work/Projects/Hello/.build/checkouts/swift-nio.git-3108475404973543938/Sources/CNIOLinux/include/c_nio_linux.h /Users/work/Projects/Hello/.build/checkouts/swift-nio-zlib-support.git--1071467962839356487/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOSHA1.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOOpenSSL.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOZlib.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIODarwin.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOHTTPParser.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOAtomics.build/module.modulemap /Users/work/Projects/Hello/.build/x86_64-apple-macosx10.10/debug/CNIOLinux.build/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes
|
D
|
/// Define the micro-threading reactor
module mecca.reactor;
// Licensed under the Boost license. Full copyright information in the AUTHORS file
static import posix_signal = core.sys.posix.signal;
static import posix_time = core.sys.posix.time;
static import posix_ucontext = core.sys.posix.ucontext;
import core.memory: GC;
import core.sys.posix.signal;
import core.sys.posix.sys.mman: munmap, mprotect, PROT_NONE;
import core.thread: thread_isMainThread;
import std.exception;
import std.string;
import std.traits;
import mecca.containers.arrays;
import mecca.containers.lists;
import mecca.containers.pools;
import mecca.lib.concurrency;
import mecca.lib.consts;
import mecca.lib.exception;
import mecca.lib.integers : bitsInValue, createBitMask;
import mecca.lib.memory;
import mecca.lib.reflection;
import mecca.lib.time;
import mecca.lib.time_queue;
import mecca.lib.typedid;
import mecca.log;
import mecca.log.impl;
import mecca.platform.linux;
import mecca.reactor.fiber_group;
import mecca.reactor.fls;
import mecca.reactor.impl.fibril: Fibril;
import mecca.reactor.subsystems.gc_tracker;
import mecca.reactor.subsystems.threading;
import mecca.reactor.sync.event: Signal;
public import mecca.reactor.types;
import std.stdio;
/// Handle for manipulating registered timers.
alias TimerHandle = Reactor.TimerHandle;
alias FiberIncarnation = ushort;
// The slot number in the stacks for the fiber
private alias FiberIdx = TypedIdentifier!("FiberIdx", ushort, ushort.max, ushort.max);
/// Track the fiber's state
enum FiberState : ubyte {
None, /// Fiber isn't running
Starting, /// Fiber was spawned, but have not yet started running
Scheduled, /// Fiber is waiting to run
Running, /// Fiber is running
Sleeping, /// Fiber is currently suspended
Done, /// Fiber has finished running
}
struct ReactorFiber {
struct OnStackParams {
Closure fiberBody;
GCStackDescriptor stackDescriptor;
FiberGroup.Chain fgChain;
FLSArea flsBlock;
ExcBuf currExcBuf;
LogsFiberSavedContext logsSavedContext;
string fiberName; // String identifying what this fiber is doing
void* fiberPtr; // The same with a numerical value
Signal joinWaiters;
}
enum Flags: ubyte {
// XXX Do we need CALLBACK_SET?
CALLBACK_SET = 0x01, /// Has callback set
SPECIAL = 0x02, /// Special fiber. Not a normal user fiber
SCHEDULED = 0x04, /// Fiber currently scheduled to be run
SLEEPING = 0x08, /// Fiber is sleeping on a sync object
HAS_EXCEPTION = 0x10, /// Fiber has pending exception to be thrown in it
EXCEPTION_BT = 0x20, /// Fiber exception needs to have fiber's backtrace
GC_ENABLED = 0x40, /// Fiber is allowed to perform GC without warning
PRIORITY = 0x80, /// Fiber is a high priority one
}
align(1):
Fibril fibril;
OnStackParams* params;
LinkedListWithOwner!(ReactorFiber*)* _owner;
FiberIdx _nextId;
FiberIdx _prevId;
FiberIncarnation incarnationCounter;
ubyte _flags;
FiberState _state;
// We define this struct align(1) for the sole purpose of making the following static assert verify what it's supposed to
static assert (this.sizeof == 32); // keep it small and cache-line friendly
// LinkedQueue access through property
@property ReactorFiber* _next() const nothrow @safe @nogc {
return to!(ReactorFiber*)(_nextId);
}
@property void _next(FiberIdx newNext) nothrow @safe @nogc {
_nextId = newNext;
}
@property void _next(ReactorFiber* newNext) nothrow @safe @nogc {
_nextId = to!FiberIdx(newNext);
}
@property ReactorFiber* _prev() const nothrow @safe @nogc {
return to!(ReactorFiber*)(_prevId);
}
@property void _prev(FiberIdx newPrev) nothrow @safe @nogc {
_prevId = newPrev;
}
@property void _prev(ReactorFiber* newPrev) nothrow @safe @nogc {
_prevId = to!FiberIdx(newPrev);
}
@notrace void setup(void[] stackArea, bool main) nothrow @nogc {
if( !main )
fibril.set(stackArea[0 .. $ - OnStackParams.sizeof], &wrapper);
params = cast(OnStackParams*)&stackArea[$ - OnStackParams.sizeof];
setToInit(params);
if( !main ) {
params.stackDescriptor.bstack = stackArea.ptr + stackArea.length; // Include params, as FLS is stored there
params.stackDescriptor.tstack = fibril.rsp;
params.stackDescriptor.add();
}
_next = null;
incarnationCounter = 0;
_flags = 0;
}
@notrace void teardown(bool main) nothrow @nogc {
fibril.reset();
if (!main) {
params.stackDescriptor.remove();
}
params = null;
}
@notrace void switchTo(ReactorFiber* next) nothrow @safe @nogc {
pragma(inline, true);
fibril.switchTo(next.fibril, ¶ms.stackDescriptor.tstack);
}
@property FiberId identity() const nothrow @safe @nogc {
FiberId.UnderlyingType res;
res = to!FiberIdx(&this).value;
res |= incarnationCounter << theReactor.maxNumFibersBits;
return FiberId(res);
}
@property bool flag(string NAME)() const pure nothrow @safe @nogc {
return (_flags & __traits(getMember, Flags, NAME)) != 0;
}
@property void flag(string NAME)(bool value) pure nothrow @safe @nogc {
if (value) {
_flags |= __traits(getMember, Flags, NAME);
}
else {
import mecca.lib.integers: bitComplement;
_flags &= bitComplement(__traits(getMember, Flags, NAME));
}
}
@property FiberState state() pure const nothrow @safe @nogc {
return _state;
}
@property void state(FiberState newState) nothrow @safe @nogc {
DBG_ASSERT!"%s trying to switch state from %s to %s, but histogram claims no fibers in this state. %s"(
theReactor.stats.fibersHistogram[_state]>0, identity, _state, newState,
theReactor.stats.fibersHistogram );
theReactor.stats.fibersHistogram[_state]--;
theReactor.stats.fibersHistogram[newState]++;
_state = newState;
}
private:
@notrace void wrapper() nothrow {
bool skipBody;
Throwable ex = null;
try {
// Nobody else will run it the first time the fiber is started. This results in some unfortunate
// code duplication
switchInto();
} catch (FiberInterrupt ex2) {
INFO!"Fiber %s killed by FiberInterrupt exception %s"(identity, ex2.msg);
skipBody = true;
} catch(Throwable ex2) {
ex = ex2;
skipBody = true;
}
while (true) {
DBG_ASSERT!"skipBody=false with pending exception"(ex is null || skipBody);
scope(exit) ex = null;
if( !skipBody ) {
params.logsSavedContext = LogsFiberSavedContext.init;
INFO!"wrapper on %s generation %s flags=0x%0x"(identity, incarnationCounter, _flags);
ASSERT!"Reactor's current fiber isn't the running fiber" (theReactor.thisFiber is &this);
ASSERT!"Fiber %s is in state %s instead of Running" (state == FiberState.Running, identity, state);
try {
// Perform the actual fiber callback
params.fiberBody();
} catch (FiberInterrupt ex2) {
INFO!"Fiber %s killed by FiberInterrupt exception: %s"(identity, ex2.msg);
} catch (Throwable ex2) {
ex = ex2;
}
}
ASSERT!"Fiber still member of fiber group at termination" (params.fgChain.owner is null);
params.joinWaiters.signal();
if( ex is null )
INFO!"wrapper finished on %s"(identity);
else
ERROR!"wrapper finished on %s with exception: %s"(identity, ex.msg);
params.fiberBody.clear();
params.fiberName = null;
params.fiberPtr = null;
flag!"CALLBACK_SET" = false;
ASSERT!"Fiber %s state is %s instead of Running at end of execution"(
state == FiberState.Running, identity, state);
state = FiberState.Done;
incarnationCounter++;
if (ex !is null) {
theReactor.forwardExceptionToMain(ex);
assert(false);
} else {
skipBody = theReactor.fiberTerminated();
}
}
}
void switchInto() @safe @nogc {
switchCurrExcBuf( ¶ms.currExcBuf );
if (!flag!"SPECIAL") {
params.flsBlock.switchTo();
} else {
FLSArea.switchToNone();
}
logSwitchInto();
if (flag!"HAS_EXCEPTION") {
Throwable ex = params.currExcBuf.get();
if (flag!"EXCEPTION_BT") {
params.currExcBuf.setTraceback(ex);
flag!"EXCEPTION_BT" = false;
}
flag!"HAS_EXCEPTION" = false;
throw ex;
}
}
void logSwitchInto() nothrow @safe @nogc{
logSwitchFiber(¶ms.logsSavedContext, cast( Parameters!logSwitchFiber[1] )identity.value);
}
}
/**
A handle to a running fiber.
This handle expires automatically when the fiber stops running. Unless you know, semantically, that a fiber is still running, don't assume
there is a running fiber attached to this handle.
The handle will correctly claim invalidity even if a new fiber is launched with the same FiberId.
*/
struct FiberHandle {
private:
FiberId identity;
FiberIncarnation incarnation;
public:
/// Returns whether the handle was set
///
/// Unlike `isValid`, this does not check whether the handle is still valid. It only returns whether the handle
/// is in initialized state.
@property bool isSet() pure const nothrow @safe @nogc {
return identity.isValid;
}
/// Returns whether the handle currently describes a running fiber.
@property bool isValid() const nothrow @safe @nogc {
return get() !is null;
}
/// returns the FiberId described by the handle. If the handle is no longer valid, will return FiberId.invalid
@property FiberId fiberId() const nothrow @safe @nogc {
if( isValid )
return identity;
return FiberId.invalid;
}
/// Reset the handle to uninitialized state
@notrace void reset() nothrow @safe @nogc {
this = FiberHandle.init;
}
package:
this(ReactorFiber* fib) nothrow @safe @nogc {
opAssign(fib);
}
auto ref opAssign(ReactorFiber* fib) nothrow @safe @nogc {
if (fib) {
identity = fib.identity;
incarnation = fib.incarnationCounter;
}
else {
identity = FiberId.invalid;
}
return this;
}
ReactorFiber* get() const nothrow @safe @nogc {
if (!identity.isValid) {
return null;
}
ReactorFiber* fiber = &theReactor.allFibers[to!FiberIdx(identity).value];
DBG_ASSERT!"Fiber state is transient state Done"(fiber.state != FiberState.Done);
if(fiber.state == FiberState.None || fiber.incarnationCounter != incarnation) {
return null;
}
return fiber;
}
}
/**
The main scheduler for the micro-threading architecture.
*/
struct Reactor {
/// Delegates passed to `registerIdleCallback` must be of this signature
alias IdleCallbackDlg = bool delegate(Duration);
/// The options control aspects of the reactor's operation
struct OpenOptions {
/// Maximum number of fibers.
uint numFibers = 256;
/// Stack size of each fiber (except the main fiber). The reactor will allocate numFiber*fiberStackSize during startup
size_t fiberStackSize = 32*KB;
/**
How often does the GC's collection run.
The reactor uses unconditional periodic collection, rather than lazy evaluation one employed by the default GC
settings. This setting sets how often the collection cycle should run.
*/
Duration gcInterval = 30.seconds;
/**
Base granularity of the reactor's timer.
Any scheduled task is scheduled at no better accuracy than timerGranularity. $(B In addition to) the fact that
a timer task may be delayed. As such, with a 1ms granularity, a task scheduled for 1.5ms from now is the same
as a task scheduled for 2ms from now, which may run 3ms from now.
*/
Duration timerGranularity = 1.msecs;
/**
Hogger detection threshold.
A hogger is a fiber that does not release the CPU to run other tasks for a long period of time. Often, this is
a result of a bug (i.e. - calling the OS's `sleep` instead of the reactor's).
Hogger detection works by measuring how long each fiber took until it allows switching away. If the fiber took
more than hoggerWarningThreshold, a warning is logged.
*/
Duration hoggerWarningThreshold = 200.msecs;
/**
Maximum desired fiber run time
A fiber should aim not to run more than this much time without a voluntary context switch. This value affects
the `shouldYield` and `considerYield` calls.
*/
Duration maxDesiredRunTime = 150.msecs;
/**
Hard hang detection.
This is a similar safeguard to that used by the hogger detection. If activated (disabled by default), it
premptively prompts the reactor every set time to see whether fibers are still being switched in/out. If it
finds that the same fiber is running, without switching out, for too long, it terminates the entire program.
*/
Duration hangDetectorTimeout = Duration.zero;
/**
Whether to enable fault handlers
The fault handlers catch program faults (such as segmentation faults) and log them with their backtrace.
*/
bool faultHandlersEnabled = true;
/// Maximal number of timers that can be simultaneously registered.
size_t numTimers = 10_000;
/// Number of threads servicing deferred tasks
uint numThreadsInPool = 4;
/// Worker thread stack size
size_t threadStackSize = 512*KB;
/// Whether we have enabled deferToThread
bool threadDeferralEnabled;
version(unittest) {
/// Disable all GC collection during the reactor run time. Only available for UTs.
bool utGcDisabled;
} else {
private enum utGcDisabled = false;
}
}
/// Used by `reportStats` to report statistics about the reactor
struct Stats {
ulong[FiberState.max+1] fibersHistogram; /// Total number of user fibers in each `FiberState`
ulong numContextSwitches; /// Number of time we switched between fibers
ulong idleCycles; /// Total number of idle cycles
/// Returns number of currently used fibers
@property ulong numUsedFibers() pure const nothrow @safe @nogc {
ulong ret;
with(FiberState) {
foreach( state; [Starting, Scheduled, Running, Sleeping]) {
ret += fibersHistogram[state];
}
}
return ret;
}
/// Returns number of fibers available to be run
@property ulong numFreeFibers() pure const nothrow @safe @nogc {
ulong ret;
with(FiberState) {
foreach( state; [None]) {
ret += fibersHistogram[state];
}
DBG_ASSERT!"%s fibers in Done state. Should be 0"(fibersHistogram[Done] == 0, fibersHistogram[Done]);
}
return ret;
}
}
private:
enum MAX_IDLE_CALLBACKS = 16;
enum TIMER_NUM_BINS = 256;
enum TIMER_NUM_LEVELS = 4;
enum MAX_DEFERRED_TASKS = 1024;
enum GUARD_ZONE_SIZE = SYS_PAGE_SIZE;
enum NUM_SPECIAL_FIBERS = 2;
enum ZERO_DURATION = Duration.zero;
enum MainFiberId = FiberId(0);
enum IdleFiberId = FiberId(1);
bool _open;
bool _running;
bool _stopping;
bool _gcCollectionNeeded;
ubyte maxNumFibersBits; // Number of bits sufficient to represent the maximal number of fibers
FiberIdx.UnderlyingType maxNumFibersMask;
int reactorReturn;
int criticalSectionNesting;
OpenOptions optionsInEffect;
Stats stats;
MmapBuffer fiberStacks;
MmapArray!ReactorFiber allFibers;
LinkedQueueWithLength!(ReactorFiber*) freeFibers;
LinkedListWithLength!(ReactorFiber*) scheduledFibers;
ReactorFiber* _thisFiber;
ReactorFiber* mainFiber;
ReactorFiber* idleFiber;
FixedArray!(IdleCallbackDlg, MAX_IDLE_CALLBACKS) idleCallbacks;
__gshared OSSignal hangDetectorSig;
posix_time.timer_t hangDetectorTimerId;
SignalHandlerValue!TscTimePoint fiberRunStartTime;
struct TimedCallback {
TimedCallback* _next, _prev;
timeQueue.OwnerAttrType _owner;
TscTimePoint timePoint;
ulong intervalCycles; // How many cycles between repeatetions. Zero means non-repeating
Closure closure;
}
// TODO change to mmap pool or something
SimplePool!(TimedCallback) timedCallbacksPool;
CascadingTimeQueue!(TimedCallback*, TIMER_NUM_BINS, TIMER_NUM_LEVELS, true) timeQueue;
ThreadPool!MAX_DEFERRED_TASKS threadPool;
public:
/// Report whether the reactor has been properly opened (i.e. - setup has been called).
@property bool isOpen() const pure nothrow @safe @nogc {
return _open;
}
/// Report whether the reactor is currently active
///
/// Unlike `isRunning`, this will return `false` during the reactor shutdown.
@property bool isActive() const pure nothrow @safe @nogc {
return _running && !_stopping;
}
/// Report whether the reactor is currently running
@property bool isRunning() const pure nothrow @safe @nogc {
return _running;
}
/**
Set the reactor up for doing work.
All options must be set before calling this function.
*/
void setup(OpenOptions options = OpenOptions.init) {
assert (!isOpen, "reactor.setup called twice");
_open = true;
assert (thread_isMainThread);
_isReactorThread = true;
assert (options.numFibers > NUM_SPECIAL_FIBERS);
reactorReturn = 0;
optionsInEffect = options;
maxNumFibersBits = bitsInValue(optionsInEffect.numFibers - 1);
maxNumFibersMask = createBitMask!(FiberIdx.UnderlyingType)(maxNumFibersBits);
stats = Stats.init;
stats.fibersHistogram[FiberState.None] = options.numFibers;
const stackPerFib = (((options.fiberStackSize + SYS_PAGE_SIZE - 1) / SYS_PAGE_SIZE) + 1) * SYS_PAGE_SIZE;
fiberStacks.allocate(stackPerFib * options.numFibers);
allFibers.allocate(options.numFibers);
_thisFiber = null;
criticalSectionNesting = 0;
idleCallbacks.length = 0;
foreach(i, ref fib; allFibers) {
auto stack = fiberStacks[i * stackPerFib .. (i + 1) * stackPerFib];
errnoEnforce(mprotect(stack.ptr, GUARD_ZONE_SIZE, PROT_NONE) == 0, "Guard zone protection failed");
fib.setup(stack[GUARD_ZONE_SIZE .. $], i==0);
if (i >= NUM_SPECIAL_FIBERS) {
freeFibers.append(&fib);
}
}
mainFiber = &allFibers[MainFiberId.value];
mainFiber.flag!"SPECIAL" = true;
mainFiber.flag!"CALLBACK_SET" = true;
mainFiber.state = FiberState.Running;
setFiberName(mainFiber, "mainFiber", &mainloop);
idleFiber = &allFibers[IdleFiberId.value];
idleFiber.flag!"SPECIAL" = true;
idleFiber.flag!"CALLBACK_SET" = true;
idleFiber.params.fiberBody.set(&idleLoop);
idleFiber.state = FiberState.Sleeping;
setFiberName(idleFiber, "idleFiber", &idleLoop);
timedCallbacksPool.open(options.numTimers, true);
timeQueue.open(options.timerGranularity);
if( options.faultHandlersEnabled )
registerFaultHandlers();
if( options.threadDeferralEnabled )
threadPool.open(options.numThreadsInPool, options.threadStackSize);
import mecca.reactor.io.fd;
_openReactorEpoll();
import mecca.reactor.io.signals;
reactorSignal._open();
}
/**
Shut the reactor down.
*/
void teardown() {
ASSERT!"reactor teardown called on non-open reactor"(isOpen);
ASSERT!"reactor teardown called on still running reactor"(!isRunning);
ASSERT!"reactor teardown called inside a critical section"(criticalSectionNesting==0);
import mecca.reactor.io.signals;
reactorSignal._close();
import mecca.reactor.io.fd;
_closeReactorEpoll();
foreach(i, ref fib; allFibers) {
fib.teardown(i==0);
}
if( optionsInEffect.threadDeferralEnabled )
threadPool.close();
switchCurrExcBuf(null);
// disableGCTracking();
if( optionsInEffect.faultHandlersEnabled )
deregisterFaultHandlers();
allFibers.free();
fiberStacks.free();
timeQueue.close();
timedCallbacksPool.close();
setToInit(freeFibers);
setToInit(scheduledFibers);
_thisFiber = null;
mainFiber = null;
idleFiber = null;
idleCallbacks.length = 0;
_isReactorThread = false;
_open = false;
}
/**
Register an idle handler callback.
The reactor handles scheduling and fibers switching, but has no built-in mechanism for scheduling sleeping fibers
back to execution (except fibers sleeping on a timer, of course). Mechanisms such as file descriptor watching are
external, and are registered using this function.
The idler callback should receive a timeout variable. This indicates the time until the closest timer expires. If
no other event comes in, the idler should strive to wake up after that long. Waking up sooner will, likely, cause
the idler to be called again. Waking up later will delay timer tasks (which is allowed by the API contract).
It is allowed to register more than one idler callback. Doing so, however, will cause $(B all) of them to be
called with a timeout of zero (i.e. - don't sleep), resulting in a busy wait for events.
The idler is expected to return a boolean value indicating whether the time spent inside the idler is to be
counted as idle time, or whether that's considered "work". This affects the results returned by the `idleCycles`
field returned by the `reactorStats`.
*/
void registerIdleCallback(IdleCallbackDlg dg) nothrow @safe @nogc {
// You will notice our deliberate lack of function to unregister
idleCallbacks ~= dg;
DEBUG!"%s idle callbacks registered"(idleCallbacks.length);
}
/**
* Spawn a new fiber for execution.
*
* Parameters:
* The first argument must be the function/delegate to call inside the new fiber. If said callable accepts further
* arguments, then they must be provided as further arguments to spawnFiber.
*
* Returns:
* A FiberHandle to the newly created fiber.
*/
@notrace FiberHandle spawnFiber(T...)(T args) nothrow @safe @nogc {
static assert(T.length>=1, "Must pass at least the function/delegate to spawnFiber");
static assert(isDelegate!(T[0]) || isFunctionPointer!(T[0]),
"spawnFiber first argument must be function or delegate");
static assert( is( ReturnType!(T[0]) == void ), "spawnFiber callback must be of type void" );
auto fib = _spawnFiber(false);
fib.params.fiberBody.set(args);
setFiberName(fib, "Fiber", args[0]);
return FiberHandle(fib);
}
/**
* Spawn a new fiber for execution.
*
* Params:
* F = The function or delegate to call inside the fiber.
* args = The arguments for F
*
* Returns:
* A FiberHandle to the newly created fiber.
*/
@notrace FiberHandle spawnFiber(alias F)(Parameters!F args) {
static assert( is( ReturnType!F == void ), "spawnFiber callback must be of type void" );
auto fib = _spawnFiber(false);
import std.algorithm: move;
// pragma(msg, genMoveArgument( args.length, "fib.params.fiberBody.set!F", "args" ) );
mixin( genMoveArgument( args.length, "fib.params.fiberBody.set!F", "args" ) );
setFiberName(fib, F.mangleof, &F);
return FiberHandle(fib);
}
/// Returns whether currently running fiber is the idle fiber.
@property bool isIdle() pure const nothrow @safe @nogc {
return thisFiber is idleFiber;
}
/// Returns whether currently running fiber is the main fiber.
@property bool isMain() pure const nothrow @safe @nogc {
return thisFiber is mainFiber;
}
/// Returns whether currently running fiber is a special (i.e. - non-user) fiber
@property bool isSpecialFiber() const nothrow @safe @nogc {
return thisFiber.flag!"SPECIAL";
}
/// Returns a FiberHandle to the currently running fiber
@property FiberHandle currentFiberHandle() nothrow @safe @nogc {
// XXX This assert may be incorrect, but it is easier to remove an assert than to add one
assert(!isSpecialFiber, "Should not blindly get fiber handle of special fibers");
return FiberHandle(thisFiber);
}
@property package ReactorFiber* currentFiberPtr() nothrow @safe @nogc {
// XXX This assert may be incorrect, but it is easier to remove an assert than to add one
assert(!isSpecialFiber, "Should not blindly get fiber handle of special fibers");
return thisFiber;
}
/**
Returns the FiberId of the currently running fiber.
You should almost never store the FiberId for later comparison or pass it to another fiber. Doing so risks having the current fiber
die and another one spawned with the same FiberId. If that's what you want to do, use currentFiberHandle instead.
*/
@property FiberId currentFiberId() const nothrow @safe @nogc {
return thisFiber.identity;
}
/// Returns the `FiberState` of the specified fiber.
FiberState getFiberState(FiberHandle fh) const nothrow @safe @nogc {
auto fiber = fh.get();
if( fiber is null )
return FiberState.None;
if( fiber.state==FiberState.Sleeping && fiber.flag!"SCHEDULED" )
return FiberState.Scheduled;
return fiber.state;
}
/**
Starts up the reactor.
The reactor should already have at least one user fiber at that point, or it will start, but sit there and do nothing.
This function "returns" only after the reactor is stopped and no more fibers are running.
Returns:
The return value from `start` is the value passed to the `stop` function.
*/
int start() {
META!"Reactor started"();
assert( idleFiber !is null, "Reactor started without calling \"setup\" first" );
mainloop();
META!"Reactor stopped"();
return reactorReturn;
}
/**
Stop the reactor, killing all fibers.
This will kill all running fibers and trigger a return from the original call to Reactor.start.
Typically, this function call never returns (throws ReactorExit). However, if stop is called while already in the
process of stopping, it will just return. It is, therefor, not wise to rely on that fact.
Params:
reactorReturn = The return value to be returned from `start`
*/
void stop(int reactorReturn = 0) @safe @nogc {
if( _stopping ) {
ERROR!"Reactor.stop called, but reactor is not running"();
return;
}
this.reactorReturn = reactorReturn;
_stopping = true;
if( !isMain() ) {
resumeSpecialFiber(mainFiber);
}
throw mkEx!ReactorExit();
}
/**
enter a no-fiber switch piece of code.
If the code tries to switch away from the current fiber before leaveCriticalSection is called, the reactor will throw an assert.
This helps writing code that does interruption sensitive tasks without locks and making sure future changes don't break it.
Critical sections are nestable.
Also see `criticalSection` below.
*/
void enterCriticalSection() pure nothrow @safe @nogc {
pragma(inline, true);
criticalSectionNesting++;
}
/// leave the innermost critical section.
void leaveCriticalSection() pure nothrow @safe @nogc {
pragma(inline, true);
assert (criticalSectionNesting > 0);
criticalSectionNesting--;
}
/// Reports whether execution is currently within a critical section
@property bool isInCriticalSection() const pure nothrow @safe @nogc {
return criticalSectionNesting > 0;
}
/**
* Return a RAII object handling a critical section
*
* The function enters a critical section. Unlike enterCriticalSection, however, there is no need to explicitly call
* leaveCriticalSection. Instead, the function returns a variable that calls leaveCriticalSection when it goes out of scope.
*
* There are two advantages for using criticalSection over enter/leaveCriticalSection. The first is for nicer scoping:
* ---
* with(theReactor.criticalSection) {
* // Code in critical section goes here
* }
* ---
*
* The second case is if you need to switch, within the same code, between critical section and none:
* ---
* auto cs = theReactor.criticalSection;
*
* // Some code
* cs.leave();
* // Some code that sleeps
* cs.enter();
*
* // The rest of the critical section code
* ---
*
* The main advantage over enter/leaveCriticalSection is that this way, the critical section never leaks. Any exception thrown, either
* from the code inside the critical section or the code temporary out of it, will result in the correct number of leaveCriticalSection
* calls to zero out the effect.
*
* Also note that there is no need to call leave at the end of the code. Cs's destructor will do it for us $(B if necessary).
*/
@property auto criticalSection() nothrow @safe @nogc {
pragma(inline, true);
static struct CriticalSection {
private:
bool owner = true;
public:
@disable this(this);
~this() nothrow @safe @nogc {
if( owner )
leave();
}
void enter() nothrow @safe @nogc {
DBG_ASSERT!"The same critical section was activated twice"(!owner);
theReactor.enterCriticalSection();
owner = true;
}
void leave() nothrow @safe @nogc {
DBG_ASSERT!"Asked to leave critical section not owned by us"(owner);
theReactor.leaveCriticalSection();
owner = false;
}
}
enterCriticalSection();
return CriticalSection();
}
unittest {
testWithReactor({
{
with( theReactor.criticalSection ) {
assertThrows!AssertError( theReactor.yield() );
}
}
theReactor.yield();
});
}
/**
* Temporarily surrender the CPU for other fibers to run.
*
* Unlike suspend, the current fiber will automatically resume running after any currently scheduled fibers are finished.
*/
@notrace void yield() @safe @nogc {
resumeFiber(thisFiber);
suspendCurrentFiber();
}
/**
* Returns whether the fiber is already running for a long time.
*
* Fibers that run for too long prevent other fibers from operating properly. On the other hand, fibers that initiate
* a context switch needlessly load the system with overhead.
*
* This function reports whether the fiber is already running more than the desired time.
*
* The base time used is taken from `OpenOptions.maxDesiredRunTime`.
*
* Params:
* tolerance = A multiplier for the amount of acceptable run time. Specifying 4 here will give you 4 times as much
* time to run before a context switch is deemed necessary.
*/
@notrace bool shouldYield(uint tolerance = 1) const nothrow @safe @nogc {
if( _stopping )
return true;
auto now = TscTimePoint.hardNow();
return (now - fiberRunStartTime) > tolerance*optionsInEffect.maxDesiredRunTime;
}
/**
Perform yield if fiber is running long enough.
Arguments and meaning are the same as for `shouldYield`.
Returns:
Whether a yield actually took place.
*/
@notrace bool considerYield(uint tolerance = 1) @safe @nogc {
if( shouldYield(tolerance) ) {
yield();
return true;
}
return false;
}
/**
Give a fiber temporary priority in execution.
Setting fiber priority means that the next time this fiber is scheduled, it will be scheduled ahead of other
fibers already scheduled to be run.
This attribute is a one-off. As soon as the fiber gets scheduled again, it will revert to being a normal fiber.
Params:
fib = FiberHandle of fiber to boost. If missing, boost the current fiber
priority = Whether to prioritize (default) of de-prioritize the fiber
*/
void boostFiberPriority(FiberHandle fib, bool priority = true) nothrow @safe @nogc {
ReactorFiber* fiber = fib.get();
if( fiber is null ) {
WARN!"Can't prioritize invalid fiber handle"();
return;
}
ASSERT!"Cannot ask to prioritize non-user fiber %s"(!fiber.flag!"SPECIAL", fiber.identity);
if( fiber.flag!"SCHEDULED" ) {
if( priority ) {
resumeFiber( fiber, true );
}
} else {
fiber.flag!"PRIORITY" = priority;
}
}
/// ditto
void boostFiberPriority(bool priority = true) nothrow @safe @nogc {
ASSERT!"Cannot ask to prioritize a non-user fiber"(!isSpecialFiber);
thisFiber.flag!"PRIORITY" = priority;
}
/// Handle used to manage registered timers
struct TimerHandle {
private:
TimedCallback* callback;
public:
/// Returns whether the handle describes a currently registered task
@property bool isValid() const nothrow @safe @nogc {
// TODO make the handle resilient to ABA changes
return callback !is null && callback._owner !is null;
}
/// Revert the handle to init value, forgetting the timer it points to
///
/// This call will $(B not) cancel the actual timer. Use `cancelTimer` for that.
@notrace void reset() nothrow @safe @nogc {
callback = null;
}
/// Cancel a currently registered timer
void cancelTimer() nothrow @safe @nogc {
if( isValid ) {
theReactor.cancelTimerInternal(this);
}
reset();
}
}
/**
* Registers a timer task.
*
* Params:
* F = the callable to be invoked when the timer expires
* timeout = when the timer is be called
* params = the parameters to call F with
*
* Returns:
* A handle to the just registered timer.
*/
TimerHandle registerTimer(alias F)(Timeout timeout, Parameters!F params) nothrow @safe @nogc {
TimedCallback* callback = timedCallbacksPool.alloc();
callback.closure.set(&F, params);
callback.timePoint = timeout.expiry;
callback.intervalCycles = 0;
timeQueue.insert(callback);
return TimerHandle(callback);
}
/// ditto
TimerHandle registerTimer(alias F)(Duration timeout, Parameters!F params) nothrow @safe @nogc {
return registerTimer!F(Timeout(timeout), params);
}
/**
* Register a timer callback
*
* Same as `registerTimer!F`, except with the callback as an argument. Callback cannot accept parameters.
*/
TimerHandle registerTimer(T)(Timeout timeout, T dg) nothrow @safe @nogc {
TimedCallback* callback = timedCallbacksPool.alloc();
callback.closure.set(dg);
callback.timePoint = timeout.expiry;
callback.intervalCycles = 0;
timeQueue.insert(callback);
return TimerHandle(callback);
}
/// ditto
TimerHandle registerTimer(T)(Duration timeout, T dg) nothrow @safe @nogc {
return registerTimer!T(Timeout(timeout), dg);
}
private TimedCallback* _registerRecurringTimer(Duration interval) nothrow @safe @nogc {
TimedCallback* callback = timedCallbacksPool.alloc();
callback.intervalCycles = TscTimePoint.toCycles(interval);
rescheduleRecurringTimer(callback);
return callback;
}
/**
* registers a timer that will repeatedly trigger at set intervals.
*
* Params:
* interval = the frequency with which the callback will be called.
* dg = the callback to invoke
* F = an alias to the function to be called
* params = the arguments to pass to F on each invocation
*/
TimerHandle registerRecurringTimer(Duration interval, void delegate() dg) nothrow @safe @nogc {
TimedCallback* callback = _registerRecurringTimer(interval);
callback.closure.set(dg);
return TimerHandle(callback);
}
/// ditto
TimerHandle registerRecurringTimer(alias F)(Duration interval, Parameters!F params) nothrow @safe @nogc {
TimedCallback* callback = _registerRecurringTimer(interval);
callback.closure.set(&F, params);
return TimerHandle(callback);
}
private void cancelTimerInternal(TimerHandle handle) nothrow @safe @nogc {
DBG_ASSERT!"cancelTimerInternal called with invalid handle"( handle.isValid );
timeQueue.cancel(handle.callback);
timedCallbacksPool.release(handle.callback);
}
/**
* Schedule a callback for out of bounds immediate execution.
*
* For all intents and purposes, `call` is identical to `registerTimer` with an expired timeout.
*/
TimerHandle call(alias F)(Parameters!F params) nothrow @safe @nogc {
return registerTimer!F(Timeout.elapsed, params);
}
/// ditto
TimerHandle call(T)(T dg) nothrow @safe @nogc {
return registerTimer(Timeout.elapsed, dg);
}
/// Suspend the current fiber for a specified amount of time
void sleep(Duration duration) @safe @nogc {
sleep(Timeout(duration));
}
/// ditto
void sleep(Timeout until) @safe @nogc {
assert(until != Timeout.init, "sleep argument uninitialized");
auto timerHandle = registerTimer!resumeFiber(until, currentFiberHandle, false);
scope(failure) timerHandle.cancelTimer();
suspendCurrentFiber();
}
/**
Resume a suspended fiber
You are heartily encouraged not to use this function directly. In almost all cases, it is better to use one of the
synchronization primitives instead.
Params:
handle = the handle of the fiber to be resumed.
priority = If true, schedule the fiber before all currently scheduled fibers. If the fiber is already scheduled
(`getFiberState` returns `Scheduled`), this will move it to the top of the queue.
*/
@notrace void resumeFiber(FiberHandle handle, bool priority = false) nothrow @safe @nogc {
resumeFiber(handle.get(), priority);
}
/**
Suspend the current fiber
If `timeout` is given and expires, the suspend will throw a `TimeoutExpired` exception.
You are heartily encouraged not to use this function directly. In almost all cases, it is better to use one of the
synchronization primitives instead.
*/
@notrace void suspendCurrentFiber(Timeout timeout) @trusted @nogc {
if (timeout == Timeout.infinite)
return suspendCurrentFiber();
ASSERT!"suspendCurrentFiber called while inside a critical section"(!isInCriticalSection);
TimerHandle timeoutHandle;
scope(exit) timeoutHandle.cancelTimer();
bool timeoutExpired;
if (timeout == Timeout.elapsed) {
throw mkEx!TimeoutExpired;
}
static void resumer(FiberHandle fibHandle, TimerHandle* cookie, bool* timeoutExpired) nothrow @safe @nogc{
*cookie = TimerHandle.init;
ReactorFiber* fib = fibHandle.get;
assert( fib !is null, "Fiber disappeared while suspended with timer" );
// Throw TimeoutExpired only if we're the ones who resumed the fiber. this prevents a race when
// someone else had already woken the fiber, but it just didn't get time to run while the timer expired.
// this probably indicates fibers hogging the CPU for too long (starving others)
*timeoutExpired = ! fib.flag!"SCHEDULED";
/+
if (! *timeoutExpired)
fib.WARN_AS!"#REACTOR fiber resumer invoked, but fiber already scheduled (starvation): %s scheduled, %s pending"(
theReactor.scheduledFibers.length, theReactor.pendingFibers.length);
+/
theReactor.resumeFiber(fib);
}
timeoutHandle = registerTimer!resumer(timeout, currentFiberHandle, &timeoutHandle, &timeoutExpired);
switchToNext();
if( timeoutExpired )
throw mkEx!TimeoutExpired();
}
/// ditto
@notrace void suspendCurrentFiber() @safe @nogc {
switchToNext();
}
/**
* run a function inside a different thread.
*
* Runs a function inside a thread. Use this function to run CPU bound processing without freezing the other fibers.
*
* `Fini`, if provided, will be called with the same parameters in the reactor thread once the thread has finished.
* `Fini` will be called unconditionally, even if the fiber that launched the thread terminates before the thread
* has finished.
*
* The `Fini` function runs within a `criticalSection`, and must not sleep.
*
* Returns:
* The return argument from the delegate is returned by this function.
*
* Throws:
* Will throw TimeoutExpired if the timeout expires.
*
* Will rethrow whatever the thread throws in the waiting fiber.
*/
auto deferToThread(alias F, alias Fini = null)(Parameters!F args, Timeout timeout = Timeout.infinite) @nogc {
DBG_ASSERT!"deferToThread called but thread deferral isn't enabled in the reactor"(
optionsInEffect.threadDeferralEnabled);
return threadPool.deferToThread!(F, Fini)(timeout, args);
}
/// ditto
auto deferToThread(F)(scope F dlg, Timeout timeout = Timeout.infinite) @nogc {
DBG_ASSERT!"deferToThread called but thread deferral isn't enabled in the reactor"(optionsInEffect.threadDeferralEnabled);
static auto glueFunction(F dlg) {
return dlg();
}
return threadPool.deferToThread!glueFunction(timeout, dlg);
}
/**
* forward an exception to another fiber
*
* This function throws an exception in another fiber. The fiber will be scheduled to run.
*
* There is a difference in semantics between the two forms. The first form throws an identical copy of the exception in the
* target fiber. The second form forms a new exception to be thrown in that fiber.
*
* One place where this difference matters is with the stack trace the thrown exception will have. With the first form, the
* stack trace will be the stack trace `ex` has, wherever it is (usually not in the fiber in which the exception was thrown).
* With the second form, the stack trace will be of the target fiber, which means it will point back to where the fiber went
* to sleep.
*/
bool throwInFiber(FiberHandle fHandle, Throwable ex) nothrow @safe @nogc {
ExcBuf* fiberEx = prepThrowInFiber(fHandle, false);
if( fiberEx is null )
return false;
fiberEx.set(ex);
auto fib = fHandle.get();
resumeFiber(fib);
return true;
}
/// ditto
bool throwInFiber(T : Throwable, string file = __FILE__, size_t line = __LINE__, A...)
(FiberHandle fHandle, auto ref A args) nothrow @safe @nogc
{
pragma(inline, true);
ExcBuf* fiberEx = prepThrowInFiber(fHandle, true);
if( fiberEx is null )
return false;
fiberEx.construct!T(file, line, false, args);
auto fib = fHandle.get();
resumeFiber(fib, true);
return true;
}
/** Request that a GC collection take place ASAP
* Params:
* waitForCollection = whether to wait for the collection to finish before returning.
*/
void requestGCCollection(bool waitForCollection = true) @safe @nogc {
if( theReactor._stopping )
return;
_gcCollectionNeeded = true;
if( theReactor.currentFiberId != MainFiberId ) {
theReactor.resumeSpecialFiber(theReactor.mainFiber);
if( waitForCollection )
yield();
}
}
/**
* Set a fiber name
*
* Used by certain diagnostic functions to distinguish the different fiber types and create histograms.
* Arguments bear no specific meaning, but default to describing the function used to start the fiber.
*/
@notrace void setFiberName(FiberHandle fh, string name, void *ptr) nothrow @safe @nogc {
setFiberName(fh.get, name, ptr);
}
/// ditto
@notrace void setFiberName(T)(FiberHandle fh, string name, scope T dlg) nothrow @safe @nogc if( isDelegate!T ) {
setFiberName(fh.get, name, dlg.ptr);
}
/**
* Wait until given fiber finishes
*/
@notrace void joinFiber(FiberHandle fh, Timeout timeout = Timeout.infinite) @safe @nogc {
ReactorFiber* fiber = fh.get();
if( fiber is null )
return;
fiber.params.joinWaiters.wait(timeout);
DBG_ASSERT!"Fiber handle %s is valid after signalling done"(!fh.isValid, fh);
}
/// Report the current reactor statistics.
@property Stats reactorStats() const nothrow @safe @nogc {
Stats ret = stats;
foreach( FiberIdx.UnderlyingType i; 0..NUM_SPECIAL_FIBERS ) {
auto fiberIdx = FiberIdx(i);
auto fiber = to!(ReactorFiber*)(fiberIdx);
DBG_ASSERT!"%s is in state %s with histogram of 0"(
ret.fibersHistogram[fiber.state]>0, fiber.identity, fiber.state );
ret.fibersHistogram[fiber.state]--;
}
return ret;
}
private:
package @property inout(ReactorFiber)* thisFiber() inout nothrow pure @safe @nogc {
DBG_ASSERT!"No current fiber as reactor was not started"(isRunning);
return _thisFiber;
}
@property bool shouldRunTimedCallbacks() nothrow @safe @nogc {
return timeQueue.cyclesTillNextEntry(TscTimePoint.hardNow()) == 0;
}
void switchToNext() @safe @nogc {
//DEBUG!"SWITCH out of %s"(thisFiber.identity);
ASSERT!"Context switch while inside a critical section"(!isInCriticalSection);
stats.numContextSwitches++;
// in source fiber
{
auto now = TscTimePoint.hardNow;
if( !thisFiber.flag!"SPECIAL" ) {
auto fiberRunTime = now - fiberRunStartTime;
if( fiberRunTime >= optionsInEffect.hoggerWarningThreshold ) {
WARN!"#HOGGER detected: Fiber %s ran for %sms"(thisFiber.identity, fiberRunTime.total!"msecs");
// TODO: Add dumping of stack trace
}
}
fiberRunStartTime = now;
if (thisFiber !is mainFiber && !mainFiber.flag!"SCHEDULED" && shouldRunTimedCallbacks()) {
resumeSpecialFiber(mainFiber);
}
else if (scheduledFibers.empty) {
resumeSpecialFiber(idleFiber);
}
assert (!scheduledFibers.empty, "scheduledList is empty");
auto currentFiber = thisFiber;
if( currentFiber.state==FiberState.Running )
currentFiber.state = FiberState.Sleeping;
else {
assertEQ( currentFiber.state, FiberState.Done, "Fiber is in incorrect state" );
currentFiber.state = FiberState.None;
}
_thisFiber = scheduledFibers.popHead();
assert (thisFiber.flag!"SCHEDULED");
thisFiber.flag!"SCHEDULED" = false;
DBG_ASSERT!"%s is in state %s, should be Sleeping or Starting"(
_thisFiber.state==FiberState.Sleeping || _thisFiber.state==FiberState.Starting,
_thisFiber.identity, _thisFiber.state);
thisFiber.state = FiberState.Running;
if (currentFiber !is thisFiber) {
// make the switch
currentFiber.switchTo(thisFiber);
}
}
// in destination fiber
{
/+
Important note:
Any code you place here *must* be replicated at the beginning of ReactorFiber.wrapper. Fibers launched
for the first time do not return from `switchTo` above.
+/
// DEBUG!"SWITCH into %s"(thisFiber.identity);
// This might throw, so it needs to be the last thing we do
thisFiber.switchInto();
}
}
bool fiberTerminated() nothrow {
ASSERT!"special fibers must never terminate" (!thisFiber.flag!"SPECIAL");
freeFibers.prepend(thisFiber);
bool skipBody = false;
try {
// Wait for next incarnation of fiber
switchToNext();
} catch (FiberInterrupt ex) {
INFO!"Fiber %s killed by FiberInterrupt exception %s"(currentFiberId, ex.msg);
skipBody = true;
} catch (Throwable ex) {
ERROR!"switchToNext on %s fiber %s failed with exception %s"(
thisFiber.state==FiberState.Running ? "just starting" : "dead", currentFiberId, ex.msg);
theReactor.forwardExceptionToMain(ex);
assert(false);
}
return skipBody;
}
void resumeSpecialFiber(ReactorFiber* fib) nothrow @safe @nogc {
assert (fib.flag!"SPECIAL");
assert (fib.flag!"CALLBACK_SET");
assert (!fib.flag!"SCHEDULED" || scheduledFibers.head is fib);
if (!fib.flag!"SCHEDULED") {
fib.flag!"SCHEDULED" = true;
scheduledFibers.prepend(fib);
}
}
void resumeFiber(ReactorFiber* fib, bool immediate = false) nothrow @safe @nogc {
assert (!fib.flag!"SPECIAL");
ASSERT!"resumeFiber called on %s, which does not have a callback set"(fib.flag!"CALLBACK_SET", fib.identity);
bool effectiveImmediate = immediate;
if (fib.flag!"PRIORITY") {
effectiveImmediate = true;
fib.flag!"PRIORITY" = false;
}
if (!fib.flag!"SCHEDULED") {
if (fib._owner !is null) {
// Whatever this fiber was waiting to do, it is no longer what it needs to be doing
fib._owner.remove(fib);
}
fib.flag!"SCHEDULED" = true;
if (effectiveImmediate) {
scheduledFibers.prepend(fib);
}
else {
scheduledFibers.append(fib);
}
} else if( immediate ) {
// If specifically asked for immediate resume, move the fiber to the beginning of the line even if already
// scheduled
scheduledFibers.remove(fib);
scheduledFibers.prepend(fib);
}
}
ReactorFiber* _spawnFiber(bool immediate) nothrow @safe @nogc {
ASSERT!"No more free fibers in pool"(!freeFibers.empty);
auto fib = freeFibers.popHead();
assert (!fib.flag!"CALLBACK_SET");
fib.flag!"CALLBACK_SET" = true;
fib.state = FiberState.Starting;
fib._prevId = FiberIdx.invalid;
fib._nextId = FiberIdx.invalid;
fib._owner = null;
fib.params.flsBlock.reset();
resumeFiber(fib, immediate);
return fib;
}
void idleLoop() {
while (true) {
TscTimePoint start, end;
end = start = TscTimePoint.hardNow;
while (scheduledFibers.empty) {
auto critSect = criticalSection();
/*
Since we've updated "end" before calling the timers, these timers won't count as idle time, unless....
after running them the scheduledFibers list is still empty, in which case they do.
*/
if( runTimedCallbacks(end) )
continue;
// We only reach here if runTimedCallbacks did nothing, in which case "end" is recent enough
Duration sleepDuration = timeQueue.timeTillNextEntry(end);
bool countsAsIdle = true;
if( idleCallbacks.length==1 ) {
countsAsIdle = idleCallbacks[0](sleepDuration) && countsAsIdle;
DBG_ASSERT!"Single idle callback must always count as idle"(countsAsIdle);
} else if ( idleCallbacks.length>1 ) {
foreach(cb; idleCallbacks) {
countsAsIdle = cb(ZERO_DURATION) && countsAsIdle;
}
} else {
DEBUG!"Idle fiber called with no callbacks, sleeping %sus"(sleepDuration.total!"usecs");
import core.thread; Thread.sleep(sleepDuration);
}
if( countsAsIdle )
end = TscTimePoint.hardNow;
}
stats.idleCycles += end.diff!"cycles"(start);
switchToNext();
}
}
@notrace bool runTimedCallbacks(TscTimePoint now = TscTimePoint.hardNow) {
// Timer callbacks are not allowed to sleep
auto criticalSectionContainer = criticalSection();
bool ret;
TimedCallback* callback;
while ((callback = timeQueue.pop(now)) !is null) {
callback.closure();
if( callback.intervalCycles==0 )
timedCallbacksPool.release(callback);
else
rescheduleRecurringTimer(callback);
ret = true;
}
return ret;
}
void rescheduleRecurringTimer(TimedCallback* callback) nothrow @safe @nogc {
ulong cycles = TscTimePoint.hardNow.cycles + callback.intervalCycles;
cycles -= cycles % callback.intervalCycles;
callback.timePoint = TscTimePoint(cycles);
timeQueue.insert(callback);
}
ExcBuf* prepThrowInFiber(FiberHandle fHandle, bool updateBT, bool specialOkay = false) nothrow @safe @nogc {
ReactorFiber* fib = fHandle.get();
ASSERT!"Cannot throw in the reactor's own fibers"( !fib.flag!"SPECIAL" || specialOkay );
if( fib is null ) {
WARN!"Failed to throw exception in fiber %s which is no longer valid"(fHandle);
return null;
}
if( fib.flag!"HAS_EXCEPTION" ) {
ERROR!"Tried to throw exception in fiber %s which already has an exception pending"(fHandle);
return null;
}
fib.flag!"HAS_EXCEPTION" = true;
fib.flag!"EXCEPTION_BT" = updateBT;
return &fib.params.currExcBuf;
}
void forwardExceptionToMain(Throwable ex) nothrow @trusted @nogc {
ExcBuf* fiberEx = prepThrowInFiber(FiberHandle(mainFiber), false, true);
if( fiberEx is null )
return;
fiberEx.set(ex);
resumeSpecialFiber(mainFiber);
as!"nothrow"(&theReactor.switchToNext);
assert(false, "switchToNext on dead system returned");
}
void registerHangDetector() @trusted @nogc {
DBG_ASSERT!"registerHangDetector called twice"( hangDetectorSig == OSSignal.SIGNONE );
hangDetectorSig = cast(OSSignal)SIGRTMIN;
scope(failure) hangDetectorSig = OSSignal.init;
posix_signal.sigaction_t sa;
sa.sa_flags = posix_signal.SA_RESTART | posix_signal.SA_ONSTACK | posix_signal.SA_SIGINFO;
sa.sa_sigaction = &hangDetectorHandler;
errnoEnforceNGC(posix_signal.sigaction(hangDetectorSig, &sa, null) == 0, "sigaction() for registering hang detector signal failed");
scope(failure) posix_signal.signal(hangDetectorSig, posix_signal.SIG_DFL);
enum SIGEV_THREAD_ID = 4;
// SIGEV_THREAD_ID (Linux-specific)
// As for SIGEV_SIGNAL, but the signal is targeted at the thread whose ID is given in sigev_notify_thread_id,
// which must be a thread in the same process as the caller. The sigev_notify_thread_id field specifies a kernel
// thread ID, that is, the value returned by clone(2) or gettid(2). This flag is intended only for use by
// threading libraries.
sigevent sev;
sev.sigev_notify = SIGEV_THREAD_ID;
sev.sigev_signo = hangDetectorSig;
sev.sigev_value.sival_ptr = &hangDetectorTimerId;
sev._sigev_un._tid = gettid();
errnoEnforceNGC(posix_time.timer_create(posix_time.CLOCK_MONOTONIC, &sev, &hangDetectorTimerId) == 0,
"timer_create for hang detector");
ASSERT!"hangDetectorTimerId is null"(hangDetectorTimerId !is posix_time.timer_t.init);
scope(failure) posix_time.timer_delete(hangDetectorTimerId);
posix_time.itimerspec its;
enum TIMER_GRANULARITY = 4; // Number of wakeups during the monitored period
Duration threshold = optionsInEffect.hangDetectorTimeout / TIMER_GRANULARITY;
threshold.split!("seconds", "nsecs")(its.it_value.tv_sec, its.it_value.tv_nsec);
its.it_interval = its.it_value;
INFO!"Hang detector will wake up every %s seconds and %s nsecs"(its.it_interval.tv_sec, its.it_interval.tv_nsec);
errnoEnforceNGC(posix_time.timer_settime(hangDetectorTimerId, 0, &its, null) == 0, "timer_settime");
}
void deregisterHangDetector() nothrow @trusted @nogc {
if( hangDetectorSig is OSSignal.SIGNONE )
return; // Hang detector was not initialized
posix_time.timer_delete(hangDetectorTimerId);
posix_signal.signal(hangDetectorSig, posix_signal.SIG_DFL);
hangDetectorSig = OSSignal.init;
}
extern(C) static void hangDetectorHandler(int signum, siginfo_t* info, void *ctx) nothrow @trusted @nogc {
auto now = TscTimePoint.hardNow();
auto delay = now - theReactor.fiberRunStartTime;
if( delay<theReactor.optionsInEffect.hangDetectorTimeout || theReactor.currentFiberId == IdleFiberId )
return;
long seconds, usecs;
delay.split!("seconds", "usecs")(seconds, usecs);
ERROR!"Hang detector triggered for %s after %s.%06s seconds"(theReactor.currentFiberId, seconds, usecs);
dumpStackTrace();
ABORT("Hang detector killed process");
}
void registerFaultHandlers() @trusted @nogc {
posix_signal.sigaction_t action;
action.sa_sigaction = &faultHandler;
action.sa_flags = posix_signal.SA_SIGINFO | posix_signal.SA_RESETHAND | posix_signal.SA_ONSTACK;
errnoEnforceNGC( posix_signal.sigaction(OSSignal.SIGSEGV, &action, null)==0, "Failed to register SIGSEGV handler" );
errnoEnforceNGC( posix_signal.sigaction(OSSignal.SIGILL, &action, null)==0, "Failed to register SIGILL handler" );
errnoEnforceNGC( posix_signal.sigaction(OSSignal.SIGBUS, &action, null)==0, "Failed to register SIGBUS handler" );
}
void deregisterFaultHandlers() nothrow @trusted @nogc {
posix_signal.signal(OSSignal.SIGBUS, posix_signal.SIG_DFL);
posix_signal.signal(OSSignal.SIGILL, posix_signal.SIG_DFL);
posix_signal.signal(OSSignal.SIGSEGV, posix_signal.SIG_DFL);
}
@notrace extern(C) static void faultHandler(int signum, siginfo_t* info, void* ctx) nothrow @trusted @nogc {
OSSignal sig = cast(OSSignal)signum;
string faultName;
switch(sig) {
case OSSignal.SIGSEGV:
faultName = "Segmentation fault";
break;
case OSSignal.SIGILL:
faultName = "Illegal instruction";
break;
case OSSignal.SIGBUS:
faultName = "Bus error";
break;
default:
faultName = "Unknown fault";
break;
}
ERROR!"#OSSIGNAL %s"(faultName);
dumpStackTrace();
flushLog(); // There is a certain chance the following lines themselves fault. Flush the logs now so that we have something
posix_ucontext.ucontext_t* contextPtr = cast(posix_ucontext.ucontext_t*)ctx;
auto pc = contextPtr ? contextPtr.uc_mcontext.gregs[posix_ucontext.REG_RIP] : 0;
if( isReactorThread ) {
auto onStackParams = theReactor.currentFiberPtr.params;
ERROR!"%s on %s address 0x%x, PC 0x%x stack params at 0x%x"(
faultName, theReactor.currentFiberId, info.si_addr, pc, onStackParams);
ERROR!"Stack is at [%s .. %s]"( onStackParams.stackDescriptor.bstack, onStackParams.stackDescriptor.tstack );
auto guardAddrStart = onStackParams.stackDescriptor.bstack - GUARD_ZONE_SIZE;
if( info.si_addr < onStackParams.stackDescriptor.bstack && info.si_addr >= guardAddrStart ) {
ERROR!"Hit stack guard area"();
}
} else {
ERROR!"%s on OS thread at address %s, PC %s"(faultName, info.si_addr, pc);
}
flushLog();
// Exit the fault handler, which will re-execute the offending instruction. Since we registered as run once, the default handler
// will then kill the node.
}
void mainloop() {
assert (isOpen);
assert (!isRunning);
assert (_thisFiber is null);
_running = true;
GC.disable();
scope(exit) GC.enable();
if( optionsInEffect.utGcDisabled ) {
// GC is disabled during the reactor run. Run it before we start
GC.collect();
}
// Don't register the hang detector until after we've finished running the GC
if( optionsInEffect.hangDetectorTimeout !is Duration.zero )
registerHangDetector();
scope(exit) {
if( optionsInEffect.hangDetectorTimeout !is Duration.zero )
deregisterHangDetector();
}
_thisFiber = mainFiber;
scope(exit) _thisFiber = null;
if( !optionsInEffect.utGcDisabled )
TimerHandle gcTimer = registerRecurringTimer!requestGCCollection(optionsInEffect.gcInterval, false);
try {
while (!_stopping) {
DBG_ASSERT!"Switched to mainloop with wrong thisFiber %s"(thisFiber is mainFiber, thisFiber.identity);
runTimedCallbacks();
if( _gcCollectionNeeded ) {
_gcCollectionNeeded = false;
TscTimePoint.hardNow(); // Update the hard now value
INFO!"#GC collection cycle started"();
GC.collect();
TscTimePoint.hardNow(); // Update the hard now value
INFO!"#GC collection cycle ended"();
}
if( !_stopping )
switchToNext();
}
} catch( ReactorExit ex ) {
ASSERT!"Main loop threw ReactorExit, but reactor is not stopping"(_stopping);
}
performStopReactor();
}
void performStopReactor() @nogc {
ASSERT!"performStopReactor must be called from the main fiber. Use Reactor.stop instead"( isMain );
Throwable reactorExit = mkEx!ReactorExit("Reactor is quitting");
foreach(ref fiber; allFibers[1..$]) { // All fibers but main
if( fiber.state == FiberState.Sleeping ) {
fiber.flag!"SPECIAL" = false;
throwInFiber(FiberHandle(&fiber), reactorExit);
}
}
thisFiber.flag!"SPECIAL" = false;
yield();
META!"Stopping reactor"();
_running = false;
_stopping = false;
}
@notrace void setFiberName(ReactorFiber* fib, string name, void *ptr) nothrow @safe @nogc {
fib.params.fiberName = name;
fib.params.fiberPtr = ptr;
}
@notrace void setFiberName(T)(ReactorFiber* fib, string name, scope T dlg) nothrow @safe @nogc if( isDelegate!T ) {
fib.params.fiberName = name;
fib.params.fiberPtr = dlg.ptr;
}
import std.string : format;
enum string decl_log_as(string logLevel) = q{
@notrace public void %1$s_AS(
string fmt, string file = __FILE__, string mod = __MODULE__, int line = __LINE__, T...)
(FiberHandle fh, T args) nothrow @safe @nogc
{
auto fiber = fh.get;
if( fiber is null ) {
ERROR!("Can't issue %1$s log as %%s. Original log: "~fmt, file, mod, line)(fh, args);
return;
}
auto currentFiber = currentFiberPtr();
fiber.logSwitchInto();
scope(exit) currentFiber.logSwitchInto();
%1$s!(fmt, file, mod, line)(args);
}
}.format(logLevel);
mixin(decl_log_as!"DEBUG");
mixin(decl_log_as!"INFO");
mixin(decl_log_as!"WARN");
mixin(decl_log_as!"ERROR");
mixin(decl_log_as!"META");
}
// Expose the conversion to/from ReactorFiber only to the reactor package
package ReactorFiber* to(T : ReactorFiber*)(FiberIdx fidx) nothrow @safe @nogc {
if (!fidx.isValid)
return null;
ASSERT!"Reactor is not open"( theReactor.isOpen );
return &theReactor.allFibers[fidx.value];
}
package FiberIdx to(T : FiberIdx)(const ReactorFiber* rfp) nothrow @safe @nogc {
if (rfp is null)
return FiberIdx.invalid;
ASSERT!"Reactor is not open"( theReactor.isOpen );
auto idx = rfp - &theReactor.allFibers.arr[0];
DBG_ASSERT!"Reactor fiber pointer not pointing to fibers pool: base %s ptr %s idx %s"(
idx>=0 && idx<theReactor.allFibers.arr.length, &theReactor.allFibers.arr[0], rfp, idx);
return FiberIdx( cast(ushort)idx );
}
package FiberIdx to(T : FiberIdx)(FiberId fiberId) nothrow @safe @nogc {
return FiberIdx( fiberId.value & theReactor.maxNumFibersMask );
}
private __gshared Reactor _theReactor;
private bool /* thread local */ _isReactorThread;
/**
* return a reference to the Reactor singleton
*
* In theory, @safe code must not access global variables. Since theReactor is only meant to be used by a single thread, however, this
* function is @trusted. If it were not, practically no code could be @safe.
*/
@property ref Reactor theReactor() nothrow @trusted @nogc {
//DBG_ASSERT!"not main thread"(_isReactorThread);
return _theReactor;
}
/// Returns whether the current thread is the thread in which theReactor is running
@property bool isReactorThread() nothrow @safe @nogc {
return _isReactorThread;
}
version (unittest) {
int testWithReactor(int delegate() dg, Reactor.OpenOptions options = Reactor.OpenOptions.init) {
sigset_t emptyMask;
errnoEnforceNGC( sigprocmask( SIG_SETMASK, &emptyMask, null )==0, "sigprocmask failed" );
theReactor.setup(options);
scope(success) theReactor.teardown();
bool succ = false;
void wrapper() {
int ret = dg();
succ = true;
theReactor.stop( ret );
}
theReactor.spawnFiber(&wrapper);
int ret = theReactor.start();
assert (succ);
return ret;
}
void testWithReactor(void delegate() dg, Reactor.OpenOptions options = Reactor.OpenOptions.init) {
int wrapper() {
dg();
return 0;
}
testWithReactor(&wrapper, options);
}
public import mecca.runtime.ut: mecca_ut;
mixin template TEST_FIXTURE_REACTOR(FIXTURE) {
import mecca.runtime.ut: runFixtureTestCases;
unittest {
testWithReactor({
runFixtureTestCases!(FIXTURE)();
});
}
}
}
unittest {
import std.stdio;
theReactor.setup();
scope(exit) theReactor.teardown();
static void fibFunc(string name) {
foreach(i; 0 .. 10) {
writeln(name);
theReactor.yield();
}
theReactor.stop();
}
theReactor.spawnFiber(&fibFunc, "hello");
theReactor.spawnFiber(&fibFunc, "world");
theReactor.start();
}
unittest {
// Test simple timeout
import std.stdio;
theReactor.setup();
scope(exit) theReactor.teardown();
uint counter;
TscTimePoint start;
void fiberFunc(Duration duration) {
INFO!"Fiber %s sleeping for %s"(theReactor.currentFiberHandle, duration.toString);
theReactor.sleep(duration);
auto now = TscTimePoint.hardNow;
counter++;
INFO!"Fiber %s woke up after %s, overshooting by %s counter is %s"(theReactor.currentFiberHandle, (now - start).toString,
((now-start) - duration).toString, counter);
}
void ender() {
INFO!"Fiber %s ender is sleeping for 250ms"(theReactor.currentFiberHandle);
theReactor.sleep(dur!"msecs"(250));
INFO!"Fiber %s ender woke up"(theReactor.currentFiberHandle);
theReactor.stop();
}
theReactor.spawnFiber(&fiberFunc, dur!"msecs"(10));
theReactor.spawnFiber(&fiberFunc, dur!"msecs"(100));
theReactor.spawnFiber(&fiberFunc, dur!"msecs"(150));
theReactor.spawnFiber(&fiberFunc, dur!"msecs"(20));
theReactor.spawnFiber(&fiberFunc, dur!"msecs"(30));
theReactor.spawnFiber(&fiberFunc, dur!"msecs"(200));
theReactor.spawnFiber(&ender);
start = TscTimePoint.hardNow;
theReactor.start();
auto end = TscTimePoint.hardNow;
INFO!"UT finished in %s"((end - start).toString);
assert(counter == 6, "Not all fibers finished");
}
unittest {
// Test suspending timeout
import std.stdio;
theReactor.setup();
scope(exit) theReactor.teardown();
void fiberFunc() {
bool thrown;
try {
theReactor.suspendCurrentFiber( Timeout(dur!"msecs"(4)) );
} catch(TimeoutExpired ex) {
thrown = true;
}
assert(thrown);
theReactor.stop();
}
theReactor.spawnFiber(&fiberFunc);
theReactor.start();
}
unittest {
// Test suspending timeout
import std.stdio;
// GC running during the test mess with the timing
Reactor.OpenOptions oo;
oo.utGcDisabled = true;
theReactor.setup(oo);
scope(exit) theReactor.teardown();
void fiberFunc() {
TimerHandle[8] handles;
Duration[8] timeouts = [
dur!"msecs"(2),
dur!"msecs"(200),
dur!"msecs"(6),
dur!"msecs"(120),
dur!"msecs"(37),
dur!"msecs"(40),
dur!"msecs"(133),
dur!"msecs"(8),
];
ubyte a;
static void timer(ubyte* a, TimerHandle* handle, ubyte bit) {
(*a) |= 1<<bit;
(*handle) = TimerHandle.init;
}
foreach(ubyte i, duration; timeouts) {
handles[i] = theReactor.registerTimer!timer( Timeout(duration), &a, &handles[i], i );
}
uint recurringCounter;
static void recurringTimer(uint* counter) {
(*counter)++;
}
TimerHandle recurringTimerHandle = theReactor.registerRecurringTimer!recurringTimer( dur!"msecs"(7), &recurringCounter );
theReactor.sleep(dur!"msecs"(3));
// Cancel one expired timeout and one yet to happen
handles[0].cancelTimer();
handles[6].cancelTimer();
// Wait for all timers to run
theReactor.sleep(dur!"msecs"(200));
assert(a == 0b1011_1111);
ASSERT!"Recurring timer should run 29 times, ran %s"(recurringCounter==29 || recurringCounter==30, recurringCounter); // 203ms / 7
theReactor.stop();
}
theReactor.spawnFiber(&fiberFunc);
theReactor.start();
}
unittest {
import mecca.reactor.sync.event;
theReactor.setup();
scope(exit) theReactor.teardown();
Event evt1, evt2;
class TheException : Exception {
this() {
super("The Exception");
}
}
void fib2() {
// Release 1
evt1.set();
try {
// Wait for 1 to do its stuff
evt2.wait();
assert( false, "Exception not thrown" );
} catch( Exception ex ) {
assert( ex.msg == "The Exception" );
}
theReactor.stop();
}
void fib1() {
assertEQ( theReactor.getFiberState(theReactor.currentFiberHandle), FiberState.Running );
assertEQ( theReactor.reactorStats.fibersHistogram[FiberState.Starting], 0 );
auto fib = theReactor.spawnFiber(&fib2);
assertEQ( theReactor.getFiberState(fib), FiberState.Starting );
assertEQ( theReactor.reactorStats.fibersHistogram[FiberState.Starting], 1 );
evt1.wait();
assertEQ( theReactor.reactorStats.fibersHistogram[FiberState.Starting], 0 );
assertEQ( theReactor.reactorStats.fibersHistogram[FiberState.Sleeping], 2 );
theReactor.throwInFiber(fib, new TheException);
// The following should be "1", because the state would switch to Scheduled. Since that's not implemented yet...
assertEQ( theReactor.reactorStats.fibersHistogram[FiberState.Sleeping], 2 ); // Should be 1
assertEQ( theReactor.reactorStats.fibersHistogram[FiberState.Scheduled], 0 ); // Should 1
evt2.set();
}
theReactor.spawnFiber(&fib1);
theReactor.start();
}
unittest {
Reactor.OpenOptions options;
options.hangDetectorTimeout = 20.msecs;
options.utGcDisabled = true;
DEBUG!"sanity: %s"(options.hangDetectorTimeout.toString);
testWithReactor({
theReactor.sleep(200.msecs);
/+
// To trigger the hang, uncomment this:
import core.thread;
Thread.sleep(200.msecs);
+/
}, options);
}
/+
unittest {
// Trigger a segmentation fault
theReactor.options.hangDetectorTimeout = 20.msecs;
DEBUG!"sanity: %s"(theReactor.options.hangDetectorTimeout);
testWithReactor({
int* a = cast(int*) 16;
*a = 3;
});
}
+/
unittest {
// No automatic failing, but at least exercise the *_AS loggers
import mecca.reactor.sync.event;
Event finish;
META!"#UT exercise log_AS functions"();
void fiberFunc() {
DEBUG!"Fiber started"();
finish.wait();
DEBUG!"Fiber finished"();
}
void testBody() {
auto fh = theReactor.spawnFiber(&fiberFunc);
theReactor.yield();
DEBUG!"Main fiber logging as %s"(fh);
theReactor.DEBUG_AS!"DEBUG trace with argument %s"(fh, 17);
theReactor.INFO_AS!"INFO trace"(fh);
theReactor.WARN_AS!"WARN trace"(fh);
theReactor.ERROR_AS!"ERROR trace"(fh);
theReactor.META_AS!"META trace"(fh);
DEBUG!"Killing fiber"();
finish.set();
theReactor.yield();
DEBUG!"Trying to log as dead fiber"();
theReactor.DEBUG_AS!"DEBUG trace on dead fiber with argument %s"(fh, 18);
}
testWithReactor(&testBody);
}
unittest {
// Make sure we do not immediately repeat the same FiberId on relaunch
FiberId fib;
void test1() {
fib = theReactor.currentFiberId();
}
void test2() {
assert(theReactor.currentFiberId() != fib);
}
testWithReactor({
theReactor.spawnFiber(&test1);
theReactor.yield();
theReactor.spawnFiber(&test2);
theReactor.yield();
});
}
unittest {
// Make sure that FiberHandle can return a ReactorFiber*
static void fiberBody() {
assert( theReactor.currentFiberPtr == theReactor.currentFiberHandle.get() );
}
testWithReactor({
theReactor.spawnFiber!fiberBody(); // Run twice to make sure the genration isn't 0
theReactor.yield();
theReactor.spawnFiber!fiberBody();
theReactor.yield();
});
}
unittest {
int ret = testWithReactor( { return 17; } );
assert( ret==17 );
}
unittest {
// test priority of scheduled fibers
uint gen;
void verify(uint expected) {
assert(gen==expected);
gen++;
}
testWithReactor({
theReactor.spawnFiber(&verify, 1);
theReactor.spawnFiber(&verify, 2);
auto fh = theReactor.spawnFiber(&verify, 0);
theReactor.spawnFiber(&verify, 3);
theReactor.boostFiberPriority(fh);
theReactor.yield();
assert(gen==4);
});
}
unittest {
// Test join
static void fiberBody() {
theReactor.yield();
theReactor.yield();
theReactor.yield();
}
testWithReactor({
FiberHandle fh = theReactor.spawnFiber!fiberBody();
assertEQ( theReactor.getFiberState(fh), FiberState.Starting );
theReactor.yield();
assertEQ( theReactor.getFiberState(fh), FiberState.Scheduled );
theReactor.joinFiber(fh);
assertEQ( theReactor.getFiberState(fh), FiberState.None );
theReactor.joinFiber(fh, Timeout(Duration.zero));
});
}
|
D
|
// Copyright Brian Schott (Hackerpilot) 2016.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
module dscanner.analysis.lambda_return_check;
import dparse.ast;
import dparse.lexer;
import dscanner.analysis.base;
final class LambdaReturnCheck : BaseAnalyzer
{
alias visit = BaseAnalyzer.visit;
this(string fileName, bool skipTests = false)
{
super(fileName, null, skipTests);
}
override void visit(const FunctionLiteralExpression fLit)
{
if (fLit.assignExpression is null)
return;
const UnaryExpression unary = cast(const UnaryExpression) fLit.assignExpression;
if (unary is null)
return;
if (unary.primaryExpression is null)
return;
if (unary.primaryExpression.functionLiteralExpression is null)
return;
if (unary.primaryExpression.functionLiteralExpression.parameters !is null)
return;
if (unary.primaryExpression.functionLiteralExpression.identifier != tok!"")
return;
if (unary.primaryExpression.functionLiteralExpression.functionBody is null)
return;
if (unary.primaryExpression.functionLiteralExpression.functionBody.blockStatement is null)
return;
addErrorMessage(fLit.line, fLit.column, KEY, "This lambda returns a lambda. Add parenthesis to clarify.");
}
private:
enum KEY = "dscanner.confusing.lambda_returns_lambda";
}
version(Windows) {/*because of newline in code*/} else
unittest
{
import dscanner.analysis.helpers : assertAnalyzerWarnings;
import dscanner.analysis.config : StaticAnalysisConfig, Check, disabledConfig;
import std.stdio : stderr;
StaticAnalysisConfig sac = disabledConfig();
sac.lambda_return_check = Check.enabled;
auto code = `
void main()
{
int[] b;
auto a = b.map!(a => { return a * a + 2; }).array(); // [warn]: This lambda returns a lambda. Add parenthesis to clarify.
pragma(msg, typeof(a => { return a; })); // [warn]: This lambda returns a lambda. Add parenthesis to clarify.
pragma(msg, typeof((a) => { return a; })); // [warn]: This lambda returns a lambda. Add parenthesis to clarify.
pragma(msg, typeof({ return a; }));
pragma(msg, typeof(a => () { return a; }));
}`c;
assertAnalyzerWarnings(code, sac);
stderr.writeln("Unittest for LambdaReturnCheck passed.");
}
|
D
|
/*
TEST_OUTPUT:
---
fail_compilation/diag14163.d(16): Error: constructor diag14163.Bar.this cannot call super() implicitly because it is annotated with @disable
---
*/
class Foo
{
@disable this();
}
class Bar : Foo
{
@disable this();
this(int i) {}
}
void main() {}
|
D
|
/Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/Validators/URLValidator.swift.o : /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validatable.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/ValidatorType.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/ValidationError.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/URLValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/AndValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/RangeValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NilIgnoringValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NilValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/EmailValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/InValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/OrValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/CharacterSetValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/CountValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NotValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/EmptyValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Exports.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/XPC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Combine.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Swift.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/IOKit.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-macos.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/cpp_magic.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/ifaddrs-android.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIODarwin/include/CNIODarwin.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/CNIOAtomics.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/CNIOLinux.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOSHA1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOHTTP1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/MySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentMySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CCryptoOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/HTTP.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOTLS.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOZlib.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOPriorityQueue.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Routing.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Random.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/URLEncodedForm.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIODarwin.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Authentication.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Crypto.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/App.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOHTTPParser.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Vapor.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOAtomics.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/WebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOWebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/TemplateKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Multipart.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOLinux.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio-zlib-support/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/xpc/XPC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/ApplicationServices.framework/Headers/ApplicationServices.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/Validators/URLValidator~partial.swiftmodule : /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validatable.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/ValidatorType.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/ValidationError.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/URLValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/AndValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/RangeValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NilIgnoringValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NilValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/EmailValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/InValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/OrValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/CharacterSetValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/CountValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NotValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/EmptyValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Exports.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/XPC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Combine.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Swift.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/IOKit.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-macos.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/cpp_magic.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/ifaddrs-android.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIODarwin/include/CNIODarwin.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/CNIOAtomics.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/CNIOLinux.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOSHA1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOHTTP1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/MySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentMySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CCryptoOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/HTTP.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOTLS.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOZlib.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOPriorityQueue.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Routing.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Random.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/URLEncodedForm.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIODarwin.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Authentication.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Crypto.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/App.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOHTTPParser.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Vapor.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOAtomics.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/WebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOWebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/TemplateKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Multipart.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOLinux.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio-zlib-support/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/xpc/XPC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/ApplicationServices.framework/Headers/ApplicationServices.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/Validators/URLValidator~partial.swiftdoc : /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validatable.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/ValidatorType.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/ValidationError.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/URLValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/AndValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/RangeValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NilIgnoringValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NilValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/EmailValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/InValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/OrValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/CharacterSetValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/CountValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NotValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/EmptyValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Exports.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/XPC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Combine.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Swift.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/IOKit.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-macos.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/cpp_magic.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/ifaddrs-android.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIODarwin/include/CNIODarwin.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/CNIOAtomics.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/CNIOLinux.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOSHA1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOHTTP1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/MySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentMySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CCryptoOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/HTTP.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOTLS.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOZlib.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOPriorityQueue.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Routing.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Random.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/URLEncodedForm.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIODarwin.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Authentication.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Crypto.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/App.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOHTTPParser.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Vapor.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOAtomics.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/WebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOWebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/TemplateKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Multipart.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOLinux.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio-zlib-support/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/xpc/XPC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/ApplicationServices.framework/Headers/ApplicationServices.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
/Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/Validators/URLValidator~partial.swiftsourceinfo : /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validatable.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/ValidatorType.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/ValidationError.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/URLValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/AndValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/RangeValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NilIgnoringValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NilValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/EmailValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/InValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/OrValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/CharacterSetValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/CountValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/NotValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validators/EmptyValidator.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Validations.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/validation/Sources/Validation/Exports.swift /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/XPC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/ObjectiveC.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Combine.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Dispatch.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Darwin.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Foundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreFoundation.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/CoreGraphics.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/Swift.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/IOKit.swiftmodule/x86_64-apple-macos.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/SwiftOnoneSupport.swiftmodule/x86_64-apple-macos.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.swiftmodule /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/cpp_magic.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/ifaddrs-android.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIODarwin/include/CNIODarwin.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOAtomics/include/CNIOAtomics.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio/Sources/CNIOLinux/include/CNIOLinux.h /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOSHA1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOHTTP1.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/MySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentMySQL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CCryptoOpenSSL.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIO.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/HTTP.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOTLS.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOZlib.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Async.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Command.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Service.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Console.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Core.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentSQLite.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOPriorityQueue.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Logging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Debugging.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Routing.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/SQLBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/FluentBenchmark.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/COperatingSystem.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Random.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/URLEncodedForm.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIODarwin.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Authentication.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Validation.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Crypto.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/App.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOHTTPParser.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Vapor.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOAtomics.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOConcurrencyHelpers.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Bits.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOFoundationCompat.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/WebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/NIOWebSocket.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/DatabaseKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/TemplateKit.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Fluent.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/Multipart.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/x86_64-apple-macosx/debug/CNIOLinux.build/module.modulemap /Users/panartem/Developer/Study/Microservices-vapor/TILAppAcronyms/.build/checkouts/swift-nio-zlib-support/module.modulemap /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/xpc/XPC.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/objc/ObjectiveC.apinotes /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/apinotes/Dispatch.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/usr/include/Darwin.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/ApplicationServices.framework/Headers/ApplicationServices.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/CoreText.framework/Headers/CoreText.apinotes /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/System/Library/Frameworks/Security.framework/Headers/Security.apinotes
|
D
|
// https://issues.dlang.org/show_bug.cgi?id=23965
// REQUIRED_ARGS: -de
deprecated:
struct S {}
void fun()
{
S[] arr;
arr ~= S();
}
|
D
|
import std.stdio;
void main(string[] args) {
writeln("For gotten the story with the idea behind this module.");
string answer = args[0];
writeln(answer);
// read();
}
|
D
|
deprecated(msg) module imports.fail19609d;
enum msg = "You won't see this either";
|
D
|
import std.stdio;
void main() {
writeln("good");
}
|
D
|
/*
* gl.d
*
* This module contains bindings for opengl and was adapted from GL.h
*
* Author: Dave Wilkinson
*
*/
module binding.opengl.gl;
version(PlatformWindows) {
pragma(lib, "opengl32.lib");
pragma(lib, "glu32.lib");
}
else {
}
// The functions supported by opengl
extern (System) {
void glAccum(GLenum op, GLfloat value);
void glAlphaFunc(GLenum func, GLclampf refr);
GLboolean glAreTexturesResident(GLsizei n, GLuint *textures, GLboolean *residences);
void glArrayElement(GLint i);
void glBegin(GLenum mode);
void glBindTexture(GLenum target, GLuint texture);
void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte *bitmap);
void glBlendFunc(GLenum sfactor, GLenum dfactor);
void glCallList(GLuint list);
void glCallLists(GLsizei n, GLenum type, GLvoid *lists);
void glClear(GLbitfield mask);
void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
void glClearDepth(GLclampd depth);
void glClearIndex(GLfloat c);
void glClearStencil(GLint s);
void glClipPlane(GLenum plane, GLdouble *equation);
void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
void glColor3bv(GLbyte *v);
void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
void glColor3dv(GLdouble *v);
void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
void glColor3fv(GLfloat *v);
void glColor3i(GLint red, GLint green, GLint blue);
void glColor3iv(GLint *v);
void glColor3s(GLshort red, GLshort green, GLshort blue);
void glColor3sv(GLshort *v);
void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
void glColor3ubv(GLubyte *v);
void glColor3ui(GLuint red, GLuint green, GLuint blue);
void glColor3uiv(GLuint *v);
void glColor3us(GLushort red, GLushort green, GLushort blue);
void glColor3usv(GLushort *v);
void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
void glColor4bv(GLbyte *v);
void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
void glColor4dv(GLdouble *v);
void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
void glColor4fv(GLfloat *v);
void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
void glColor4iv(GLint *v);
void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
void glColor4sv(GLshort *v);
void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
void glColor4ubv(GLubyte *v);
void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
void glColor4uiv(GLuint *v);
void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
void glColor4usv(GLushort *v);
void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
void glColorMaterial(GLenum face, GLenum mode);
void glColorPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
void glCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
void glCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
void glCullFace(GLenum mode);
void glDeleteLists(GLuint list, GLsizei range);
void glDeleteTextures(GLsizei n, GLuint *textures);
void glDepthFunc(GLenum func);
void glDepthMask(GLboolean flag);
void glDepthRange(GLclampd zNear, GLclampd zFar);
void glDisable(GLenum cap);
void glDisableClientState(GLenum array);
void glDrawArrays(GLenum mode, GLint first, GLsizei count);
void glDrawBuffer(GLenum mode);
void glDrawElements(GLenum mode, GLsizei count, GLenum type, GLvoid *indices);
void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
void glEdgeFlag(GLboolean flag);
void glEdgeFlagPointer(GLsizei stride, GLvoid *pointer);
void glEdgeFlagv(GLboolean *flag);
void glEnable(GLenum cap);
void glEnableClientState(GLenum array);
void glEnd();
void glEndList();
void glEvalCoord1d(GLdouble u);
void glEvalCoord1dv(GLdouble *u);
void glEvalCoord1f(GLfloat u);
void glEvalCoord1fv(GLfloat *u);
void glEvalCoord2d(GLdouble u, GLdouble v);
void glEvalCoord2dv(GLdouble *u);
void glEvalCoord2f(GLfloat u, GLfloat v);
void glEvalCoord2fv(GLfloat *u);
void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
void glEvalPoint1(GLint i);
void glEvalPoint2(GLint i, GLint j);
void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
void glFinish();
void glFlush();
void glFogf(GLenum pname, GLfloat param);
void glFogfv(GLenum pname, GLfloat *params);
void glFogi(GLenum pname, GLint param);
void glFogiv(GLenum pname, GLint *params);
void glFrontFace(GLenum mode);
void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
GLuint glGenLists(GLsizei range);
void glGenTextures(GLsizei n, GLuint *textures);
void glGetBooleanv(GLenum pname, GLboolean *params);
void glGetClipPlane(GLenum plane, GLdouble *equation);
void glGetDoublev(GLenum pname, GLdouble *params);
GLenum glGetError();
void glGetFloatv(GLenum pname, GLfloat *params);
void glGetIntegerv(GLenum pname, GLint *params);
void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
void glGetLightiv(GLenum light, GLenum pname, GLint *params);
void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
void glGetMapiv(GLenum target, GLenum query, GLint *v);
void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
void glGetPixelMapfv(GLenum map, GLfloat *values);
void glGetPixelMapuiv(GLenum map, GLuint *values);
void glGetPixelMapusv(GLenum map, GLushort *values);
void glGetPointerv(GLenum pname, GLvoid **params);
void glGetPolygonStipple(GLubyte *mask);
GLubyte * glGetString(GLenum name);
void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
void glHint(GLenum target, GLenum mode);
void glIndexMask(GLuint mask);
void glIndexPointer(GLenum type, GLsizei stride, GLvoid *pointer);
void glIndexd(GLdouble c);
void glIndexdv(GLdouble *c);
void glIndexf(GLfloat c);
void glIndexfv(GLfloat *c);
void glIndexi(GLint c);
void glIndexiv(GLint *c);
void glIndexs(GLshort c);
void glIndexsv(GLshort *c);
void glIndexub(GLubyte c);
void glIndexubv(GLubyte *c);
void glInitNames();
void glInterleavedArrays(GLenum format, GLsizei stride, GLvoid *pointer);
GLboolean glIsEnabled(GLenum cap);
GLboolean glIsList(GLuint list);
GLboolean glIsTexture(GLuint texture);
void glLightModelf(GLenum pname, GLfloat param);
void glLightModelfv(GLenum pname, GLfloat *params);
void glLightModeli(GLenum pname, GLint param);
void glLightModeliv(GLenum pname, GLint *params);
void glLightf(GLenum light, GLenum pname, GLfloat param);
void glLightfv(GLenum light, GLenum pname, GLfloat *params);
void glLighti(GLenum light, GLenum pname, GLint param);
void glLightiv(GLenum light, GLenum pname, GLint *params);
void glLineStipple(GLint factor, GLushort pattern);
void glLineWidth(GLfloat width);
void glListBase(GLuint base);
void glLoadIdentity();
void glLoadMatrixd(GLdouble *m);
void glLoadMatrixf(GLfloat *m);
void glLoadName(GLuint name);
void glLogicOp(GLenum opcode);
void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble *points);
void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat *points);
void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble *points);
void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat *points);
void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
void glMaterialf(GLenum face, GLenum pname, GLfloat param);
void glMaterialfv(GLenum face, GLenum pname, GLfloat *params);
void glMateriali(GLenum face, GLenum pname, GLint param);
void glMaterialiv(GLenum face, GLenum pname, GLint *params);
void glMatrixMode(GLenum mode);
void glMultMatrixd(GLdouble *m);
void glMultMatrixf(GLfloat *m);
void glNewList(GLuint list, GLenum mode);
void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
void glNormal3bv(GLbyte *v);
void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
void glNormal3dv(GLdouble *v);
void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
void glNormal3fv(GLfloat *v);
void glNormal3i(GLint nx, GLint ny, GLint nz);
void glNormal3iv(GLint *v);
void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
void glNormal3sv(GLshort *v);
void glNormalPointer(GLenum type, GLsizei stride, GLvoid *pointer);
void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
void glPassThrough(GLfloat token);
void glPixelMapfv(GLenum map, GLsizei mapsize, GLfloat *values);
void glPixelMapuiv(GLenum map, GLsizei mapsize, GLuint *values);
void glPixelMapusv(GLenum map, GLsizei mapsize, GLushort *values);
void glPixelStoref(GLenum pname, GLfloat param);
void glPixelStorei(GLenum pname, GLint param);
void glPixelTransferf(GLenum pname, GLfloat param);
void glPixelTransferi(GLenum pname, GLint param);
void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
void glPointSize(GLfloat size);
void glPolygonMode(GLenum face, GLenum mode);
void glPolygonOffset(GLfloat factor, GLfloat units);
void glPolygonStipple(GLubyte *mask);
void glPopAttrib();
void glPopClientAttrib();
void glPopMatrix();
void glPopName();
void glPrioritizeTextures(GLsizei n, GLuint *textures, GLclampf *priorities);
void glPushAttrib(GLbitfield mask);
void glPushClientAttrib(GLbitfield mask);
void glPushMatrix();
void glPushName(GLuint name);
void glRasterPos2d(GLdouble x, GLdouble y);
void glRasterPos2dv(GLdouble *v);
void glRasterPos2f(GLfloat x, GLfloat y);
void glRasterPos2fv(GLfloat *v);
void glRasterPos2i(GLint x, GLint y);
void glRasterPos2iv(GLint *v);
void glRasterPos2s(GLshort x, GLshort y);
void glRasterPos2sv(GLshort *v);
void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
void glRasterPos3dv(GLdouble *v);
void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
void glRasterPos3fv(GLfloat *v);
void glRasterPos3i(GLint x, GLint y, GLint z);
void glRasterPos3iv(GLint *v);
void glRasterPos3s(GLshort x, GLshort y, GLshort z);
void glRasterPos3sv(GLshort *v);
void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
void glRasterPos4dv(GLdouble *v);
void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
void glRasterPos4fv(GLfloat *v);
void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
void glRasterPos4iv(GLint *v);
void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
void glRasterPos4sv(GLshort *v);
void glReadBuffer(GLenum mode);
void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
void glRectdv(GLdouble *v1, GLdouble *v2);
void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
void glRectfv(GLfloat *v1, GLfloat *v2);
void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
void glRectiv(GLint *v1, GLint *v2);
void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
void glRectsv(GLshort *v1, GLshort *v2);
GLint glRenderMode(GLenum mode);
void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
void glScaled(GLdouble x, GLdouble y, GLdouble z);
void glScalef(GLfloat x, GLfloat y, GLfloat z);
void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
void glSelectBuffer(GLsizei size, GLuint *buffer);
void glShadeModel(GLenum mode);
void glStencilFunc(GLenum func, GLint refr, GLuint mask);
void glStencilMask(GLuint mask);
void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
void glTexCoord1d(GLdouble s);
void glTexCoord1dv(GLdouble *v);
void glTexCoord1f(GLfloat s);
void glTexCoord1fv(GLfloat *v);
void glTexCoord1i(GLint s);
void glTexCoord1iv(GLint *v);
void glTexCoord1s(GLshort s);
void glTexCoord1sv(GLshort *v);
void glTexCoord2d(GLdouble s, GLdouble t);
void glTexCoord2dv(GLdouble *v);
void glTexCoord2f(GLfloat s, GLfloat t);
void glTexCoord2fv(GLfloat *v);
void glTexCoord2i(GLint s, GLint t);
void glTexCoord2iv(GLint *v);
void glTexCoord2s(GLshort s, GLshort t);
void glTexCoord2sv(GLshort *v);
void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
void glTexCoord3dv(GLdouble *v);
void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
void glTexCoord3fv(GLfloat *v);
void glTexCoord3i(GLint s, GLint t, GLint r);
void glTexCoord3iv(GLint *v);
void glTexCoord3s(GLshort s, GLshort t, GLshort r);
void glTexCoord3sv(GLshort *v);
void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
void glTexCoord4dv(GLdouble *v);
void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
void glTexCoord4fv(GLfloat *v);
void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
void glTexCoord4iv(GLint *v);
void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
void glTexCoord4sv(GLshort *v);
void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
void glTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
void glTexEnvi(GLenum target, GLenum pname, GLint param);
void glTexEnviv(GLenum target, GLenum pname, GLint *params);
void glTexGend(GLenum coord, GLenum pname, GLdouble param);
void glTexGendv(GLenum coord, GLenum pname, GLdouble *params);
void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
void glTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
void glTexGeni(GLenum coord, GLenum pname, GLint param);
void glTexGeniv(GLenum coord, GLenum pname, GLint *params);
void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, GLvoid *pixels);
void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid *pixels);
void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
void glTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
void glTexParameteri(GLenum target, GLenum pname, GLint param);
void glTexParameteriv(GLenum target, GLenum pname, GLint *params);
void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, GLvoid *pixels);
void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
void glTranslated(GLdouble x, GLdouble y, GLdouble z);
void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
void glVertex2d(GLdouble x, GLdouble y);
void glVertex2dv(GLdouble *v);
void glVertex2f(GLfloat x, GLfloat y);
void glVertex2fv(GLfloat *v);
void glVertex2i(GLint x, GLint y);
void glVertex2iv(GLint *v);
void glVertex2s(GLshort x, GLshort y);
void glVertex2sv(GLshort *v);
void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
void glVertex3dv(GLdouble *v);
void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
void glVertex3fv(GLfloat *v);
void glVertex3i(GLint x, GLint y, GLint z);
void glVertex3iv(GLint *v);
void glVertex3s(GLshort x, GLshort y, GLshort z);
void glVertex3sv(GLshort *v);
void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
void glVertex4dv(GLdouble *v);
void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
void glVertex4fv(GLfloat *v);
void glVertex4i(GLint x, GLint y, GLint z, GLint w);
void glVertex4iv(GLint *v);
void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
void glVertex4sv(GLshort *v);
void glVertexPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
}
alias uint GLenum;
alias ubyte GLboolean;
alias uint GLbitfield;
alias byte GLbyte;
alias short GLshort;
alias int GLint;
alias int GLsizei;
alias ubyte GLubyte;
alias ushort GLushort;
alias uint GLuint;
alias float GLfloat;
alias float GLclampf;
alias double GLdouble;
alias double GLclampd;
alias void GLvoid;
/*************************************************************/
/* Version */
const GL_VERSION_1_1 = 1;
/* AccumOp */
const GL_ACCUM = 0x0100;
const GL_LOAD = 0x0101;
const GL_RETURN = 0x0102;
const GL_MULT = 0x0103;
const GL_ADD = 0x0104;
/* AlphaFunction */
const GL_NEVER = 0x0200;
const GL_LESS = 0x0201;
const GL_EQUAL = 0x0202;
const GL_LEQUAL = 0x0203;
const GL_GREATER = 0x0204;
const GL_NOTEQUAL = 0x0205;
const GL_GEQUAL = 0x0206;
const GL_ALWAYS = 0x0207;
/* AttribMask */
const GL_CURRENT_BIT = 0x00000001;
const GL_POINT_BIT = 0x00000002;
const GL_LINE_BIT = 0x00000004;
const GL_POLYGON_BIT = 0x00000008;
const GL_POLYGON_STIPPLE_BIT = 0x00000010;
const GL_PIXEL_MODE_BIT = 0x00000020;
const GL_LIGHTING_BIT = 0x00000040;
const GL_FOG_BIT = 0x00000080;
const GL_DEPTH_BUFFER_BIT = 0x00000100;
const GL_ACCUM_BUFFER_BIT = 0x00000200;
const GL_STENCIL_BUFFER_BIT = 0x00000400;
const GL_VIEWPORT_BIT = 0x00000800;
const GL_TRANSFORM_BIT = 0x00001000;
const GL_ENABLE_BIT = 0x00002000;
const GL_COLOR_BUFFER_BIT = 0x00004000;
const GL_HINT_BIT = 0x00008000;
const GL_EVAL_BIT = 0x00010000;
const GL_LIST_BIT = 0x00020000;
const GL_TEXTURE_BIT = 0x00040000;
const GL_SCISSOR_BIT = 0x00080000;
const GL_ALL_ATTRIB_BITS = 0x000fffff;
/* BeginMode */
const GL_POINTS = 0x0000;
const GL_LINES = 0x0001;
const GL_LINE_LOOP = 0x0002;
const GL_LINE_STRIP = 0x0003;
const GL_TRIANGLES = 0x0004;
const GL_TRIANGLE_STRIP = 0x0005;
const GL_TRIANGLE_FAN = 0x0006;
const GL_QUADS = 0x0007;
const GL_QUAD_STRIP = 0x0008;
const GL_POLYGON = 0x0009;
/* BlendingFactorDest */
const GL_ZERO = 0;
const GL_ONE = 1;
const GL_SRC_COLOR = 0x0300;
const GL_ONE_MINUS_SRC_COLOR = 0x0301;
const GL_SRC_ALPHA = 0x0302;
const GL_ONE_MINUS_SRC_ALPHA = 0x0303;
const GL_DST_ALPHA = 0x0304;
const GL_ONE_MINUS_DST_ALPHA = 0x0305;
/* BlendingFactorSrc */
/* GL_ZERO */
/* GL_ONE */
const GL_DST_COLOR = 0x0306;
const GL_ONE_MINUS_DST_COLOR = 0x0307;
/* GL_SRC_ALPHA */
const GL_SRC_ALPHA_SATURATE = 0x0308;
/* GL_ONE_MINUS_SRC_ALPHA */
/* GL_DST_ALPHA */
/* GL_ONE_MINUS_DST_ALPHA */
/* Boolean */
const GL_TRUE = 1;
const GL_FALSE = 0;
/* ClearBufferMask */
/* GL_COLOR_BUFFER_BIT */
/* GL_ACCUM_BUFFER_BIT */
/* GL_STENCIL_BUFFER_BIT */
/* GL_DEPTH_BUFFER_BIT */
/* ClientArrayType */
/* GL_VERTEX_ARRAY */
/* GL_NORMAL_ARRAY */
/* GL_COLOR_ARRAY */
/* GL_INDEX_ARRAY */
/* GL_TEXTURE_COORD_ARRAY */
/* GL_EDGE_FLAG_ARRAY */
/* ClipPlaneName */
const GL_CLIP_PLANE0 = 0x3000;
const GL_CLIP_PLANE1 = 0x3001;
const GL_CLIP_PLANE2 = 0x3002;
const GL_CLIP_PLANE3 = 0x3003;
const GL_CLIP_PLANE4 = 0x3004;
const GL_CLIP_PLANE5 = 0x3005;
/* ColorMaterialFace */
/* GL_FRONT */
/* GL_BACK */
/* GL_FRONT_AND_BACK */
/* ColorMaterialParameter */
/* GL_AMBIENT */
/* GL_DIFFUSE */
/* GL_SPECULAR */
/* GL_EMISSION */
/* GL_AMBIENT_AND_DIFFUSE */
/* ColorPointerType */
/* GL_BYTE */
/* GL_UNSIGNED_BYTE */
/* GL_SHORT */
/* GL_UNSIGNED_SHORT */
/* GL_INT */
/* GL_UNSIGNED_INT */
/* GL_FLOAT */
/* GL_DOUBLE */
/* CullFaceMode */
/* GL_FRONT */
/* GL_BACK */
/* GL_FRONT_AND_BACK */
/* DataType */
const GL_BYTE = 0x1400;
const GL_UNSIGNED_BYTE = 0x1401;
const GL_SHORT = 0x1402;
const GL_UNSIGNED_SHORT = 0x1403;
const GL_INT = 0x1404;
const GL_UNSIGNED_INT = 0x1405;
const GL_FLOAT = 0x1406;
const GL_2_BYTES = 0x1407;
const GL_3_BYTES = 0x1408;
const GL_4_BYTES = 0x1409;
const GL_DOUBLE = 0x140A;
/* DepthFunction */
/* GL_NEVER */
/* GL_LESS */
/* GL_EQUAL */
/* GL_LEQUAL */
/* GL_GREATER */
/* GL_NOTEQUAL */
/* GL_GEQUAL */
/* GL_ALWAYS */
/* DrawBufferMode */
const GL_NONE = 0;
const GL_FRONT_LEFT = 0x0400;
const GL_FRONT_RIGHT = 0x0401;
const GL_BACK_LEFT = 0x0402;
const GL_BACK_RIGHT = 0x0403;
const GL_FRONT = 0x0404;
const GL_BACK = 0x0405;
const GL_LEFT = 0x0406;
const GL_RIGHT = 0x0407;
const GL_FRONT_AND_BACK = 0x0408;
const GL_AUX0 = 0x0409;
const GL_AUX1 = 0x040A;
const GL_AUX2 = 0x040B;
const GL_AUX3 = 0x040C;
/* Enable */
/* GL_FOG */
/* GL_LIGHTING */
/* GL_TEXTURE_1D */
/* GL_TEXTURE_2D */
/* GL_LINE_STIPPLE */
/* GL_POLYGON_STIPPLE */
/* GL_CULL_FACE */
/* GL_ALPHA_TEST */
/* GL_BLEND */
/* GL_INDEX_LOGIC_OP */
/* GL_COLOR_LOGIC_OP */
/* GL_DITHER */
/* GL_STENCIL_TEST */
/* GL_DEPTH_TEST */
/* GL_CLIP_PLANE0 */
/* GL_CLIP_PLANE1 */
/* GL_CLIP_PLANE2 */
/* GL_CLIP_PLANE3 */
/* GL_CLIP_PLANE4 */
/* GL_CLIP_PLANE5 */
/* GL_LIGHT0 */
/* GL_LIGHT1 */
/* GL_LIGHT2 */
/* GL_LIGHT3 */
/* GL_LIGHT4 */
/* GL_LIGHT5 */
/* GL_LIGHT6 */
/* GL_LIGHT7 */
/* GL_TEXTURE_GEN_S */
/* GL_TEXTURE_GEN_T */
/* GL_TEXTURE_GEN_R */
/* GL_TEXTURE_GEN_Q */
/* GL_MAP1_VERTEX_3 */
/* GL_MAP1_VERTEX_4 */
/* GL_MAP1_COLOR_4 */
/* GL_MAP1_INDEX */
/* GL_MAP1_NORMAL */
/* GL_MAP1_TEXTURE_COORD_1 */
/* GL_MAP1_TEXTURE_COORD_2 */
/* GL_MAP1_TEXTURE_COORD_3 */
/* GL_MAP1_TEXTURE_COORD_4 */
/* GL_MAP2_VERTEX_3 */
/* GL_MAP2_VERTEX_4 */
/* GL_MAP2_COLOR_4 */
/* GL_MAP2_INDEX */
/* GL_MAP2_NORMAL */
/* GL_MAP2_TEXTURE_COORD_1 */
/* GL_MAP2_TEXTURE_COORD_2 */
/* GL_MAP2_TEXTURE_COORD_3 */
/* GL_MAP2_TEXTURE_COORD_4 */
/* GL_POINT_SMOOTH */
/* GL_LINE_SMOOTH */
/* GL_POLYGON_SMOOTH */
/* GL_SCISSOR_TEST */
/* GL_COLOR_MATERIAL */
/* GL_NORMALIZE */
/* GL_AUTO_NORMAL */
/* GL_VERTEX_ARRAY */
/* GL_NORMAL_ARRAY */
/* GL_COLOR_ARRAY */
/* GL_INDEX_ARRAY */
/* GL_TEXTURE_COORD_ARRAY */
/* GL_EDGE_FLAG_ARRAY */
/* GL_POLYGON_OFFSET_POINT */
/* GL_POLYGON_OFFSET_LINE */
/* GL_POLYGON_OFFSET_FILL */
/* ErrorCode */
const GL_NO_ERROR = 0;
const GL_INVALID_ENUM = 0x0500;
const GL_INVALID_VALUE = 0x0501;
const GL_INVALID_OPERATION = 0x0502;
const GL_STACK_OVERFLOW = 0x0503;
const GL_STACK_UNDERFLOW = 0x0504;
const GL_OUT_OF_MEMORY = 0x0505;
/* FeedBackMode */
const GL_2D = 0x0600;
const GL_3D = 0x0601;
const GL_3D_COLOR = 0x0602;
const GL_3D_COLOR_TEXTURE = 0x0603;
const GL_4D_COLOR_TEXTURE = 0x0604;
/* FeedBackToken */
const GL_PASS_THROUGH_TOKEN = 0x0700;
const GL_POINT_TOKEN = 0x0701;
const GL_LINE_TOKEN = 0x0702;
const GL_POLYGON_TOKEN = 0x0703;
const GL_BITMAP_TOKEN = 0x0704;
const GL_DRAW_PIXEL_TOKEN = 0x0705;
const GL_COPY_PIXEL_TOKEN = 0x0706;
const GL_LINE_RESET_TOKEN = 0x0707;
/* FogMode */
/* GL_LINEAR */
const GL_EXP = 0x0800;
const GL_EXP2 = 0x0801;
/* FogParameter */
/* GL_FOG_COLOR */
/* GL_FOG_DENSITY */
/* GL_FOG_END */
/* GL_FOG_INDEX */
/* GL_FOG_MODE */
/* GL_FOG_START */
/* FrontFaceDirection */
const GL_CW = 0x0900;
const GL_CCW = 0x0901;
/* GetMapTarget */
const GL_COEFF = 0x0A00;
const GL_ORDER = 0x0A01;
const GL_DOMAIN = 0x0A02;
/* GetPixelMap */
/* GL_PIXEL_MAP_I_TO_I */
/* GL_PIXEL_MAP_S_TO_S */
/* GL_PIXEL_MAP_I_TO_R */
/* GL_PIXEL_MAP_I_TO_G */
/* GL_PIXEL_MAP_I_TO_B */
/* GL_PIXEL_MAP_I_TO_A */
/* GL_PIXEL_MAP_R_TO_R */
/* GL_PIXEL_MAP_G_TO_G */
/* GL_PIXEL_MAP_B_TO_B */
/* GL_PIXEL_MAP_A_TO_A */
/* GetPointerTarget */
/* GL_VERTEX_ARRAY_POINTER */
/* GL_NORMAL_ARRAY_POINTER */
/* GL_COLOR_ARRAY_POINTER */
/* GL_INDEX_ARRAY_POINTER */
/* GL_TEXTURE_COORD_ARRAY_POINTER */
/* GL_EDGE_FLAG_ARRAY_POINTER */
/* GetTarget */
const GL_CURRENT_COLOR = 0x0B00;
const GL_CURRENT_INDEX = 0x0B01;
const GL_CURRENT_NORMAL = 0x0B02;
const GL_CURRENT_TEXTURE_COORDS = 0x0B03;
const GL_CURRENT_RASTER_COLOR = 0x0B04;
const GL_CURRENT_RASTER_INDEX = 0x0B05;
const GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06;
const GL_CURRENT_RASTER_POSITION = 0x0B07;
const GL_CURRENT_RASTER_POSITION_VALID = 0x0B08;
const GL_CURRENT_RASTER_DISTANCE = 0x0B09;
const GL_POINT_SMOOTH = 0x0B10;
const GL_POINT_SIZE = 0x0B11;
const GL_POINT_SIZE_RANGE = 0x0B12;
const GL_POINT_SIZE_GRANULARITY = 0x0B13;
const GL_LINE_SMOOTH = 0x0B20;
const GL_LINE_WIDTH = 0x0B21;
const GL_LINE_WIDTH_RANGE = 0x0B22;
const GL_LINE_WIDTH_GRANULARITY = 0x0B23;
const GL_LINE_STIPPLE = 0x0B24;
const GL_LINE_STIPPLE_PATTERN = 0x0B25;
const GL_LINE_STIPPLE_REPEAT = 0x0B26;
const GL_LIST_MODE = 0x0B30;
const GL_MAX_LIST_NESTING = 0x0B31;
const GL_LIST_BASE = 0x0B32;
const GL_LIST_INDEX = 0x0B33;
const GL_POLYGON_MODE = 0x0B40;
const GL_POLYGON_SMOOTH = 0x0B41;
const GL_POLYGON_STIPPLE = 0x0B42;
const GL_EDGE_FLAG = 0x0B43;
const GL_CULL_FACE = 0x0B44;
const GL_CULL_FACE_MODE = 0x0B45;
const GL_FRONT_FACE = 0x0B46;
const GL_LIGHTING = 0x0B50;
const GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51;
const GL_LIGHT_MODEL_TWO_SIDE = 0x0B52;
const GL_LIGHT_MODEL_AMBIENT = 0x0B53;
const GL_SHADE_MODEL = 0x0B54;
const GL_COLOR_MATERIAL_FACE = 0x0B55;
const GL_COLOR_MATERIAL_PARAMETER = 0x0B56;
const GL_COLOR_MATERIAL = 0x0B57;
const GL_FOG = 0x0B60;
const GL_FOG_INDEX = 0x0B61;
const GL_FOG_DENSITY = 0x0B62;
const GL_FOG_START = 0x0B63;
const GL_FOG_END = 0x0B64;
const GL_FOG_MODE = 0x0B65;
const GL_FOG_COLOR = 0x0B66;
const GL_DEPTH_RANGE = 0x0B70;
const GL_DEPTH_TEST = 0x0B71;
const GL_DEPTH_WRITEMASK = 0x0B72;
const GL_DEPTH_CLEAR_VALUE = 0x0B73;
const GL_DEPTH_FUNC = 0x0B74;
const GL_ACCUM_CLEAR_VALUE = 0x0B80;
const GL_STENCIL_TEST = 0x0B90;
const GL_STENCIL_CLEAR_VALUE = 0x0B91;
const GL_STENCIL_FUNC = 0x0B92;
const GL_STENCIL_VALUE_MASK = 0x0B93;
const GL_STENCIL_FAIL = 0x0B94;
const GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95;
const GL_STENCIL_PASS_DEPTH_PASS = 0x0B96;
const GL_STENCIL_REF = 0x0B97;
const GL_STENCIL_WRITEMASK = 0x0B98;
const GL_MATRIX_MODE = 0x0BA0;
const GL_NORMALIZE = 0x0BA1;
const GL_VIEWPORT = 0x0BA2;
const GL_MODELVIEW_STACK_DEPTH = 0x0BA3;
const GL_PROJECTION_STACK_DEPTH = 0x0BA4;
const GL_TEXTURE_STACK_DEPTH = 0x0BA5;
const GL_MODELVIEW_MATRIX = 0x0BA6;
const GL_PROJECTION_MATRIX = 0x0BA7;
const GL_TEXTURE_MATRIX = 0x0BA8;
const GL_ATTRIB_STACK_DEPTH = 0x0BB0;
const GL_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1;
const GL_ALPHA_TEST = 0x0BC0;
const GL_ALPHA_TEST_FUNC = 0x0BC1;
const GL_ALPHA_TEST_REF = 0x0BC2;
const GL_DITHER = 0x0BD0;
const GL_BLEND_DST = 0x0BE0;
const GL_BLEND_SRC = 0x0BE1;
const GL_BLEND = 0x0BE2;
const GL_LOGIC_OP_MODE = 0x0BF0;
const GL_INDEX_LOGIC_OP = 0x0BF1;
const GL_COLOR_LOGIC_OP = 0x0BF2;
const GL_AUX_BUFFERS = 0x0C00;
const GL_DRAW_BUFFER = 0x0C01;
const GL_READ_BUFFER = 0x0C02;
const GL_SCISSOR_BOX = 0x0C10;
const GL_SCISSOR_TEST = 0x0C11;
const GL_INDEX_CLEAR_VALUE = 0x0C20;
const GL_INDEX_WRITEMASK = 0x0C21;
const GL_COLOR_CLEAR_VALUE = 0x0C22;
const GL_COLOR_WRITEMASK = 0x0C23;
const GL_INDEX_MODE = 0x0C30;
const GL_RGBA_MODE = 0x0C31;
const GL_DOUBLEBUFFER = 0x0C32;
const GL_STEREO = 0x0C33;
const GL_RENDER_MODE = 0x0C40;
const GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50;
const GL_POINT_SMOOTH_HINT = 0x0C51;
const GL_LINE_SMOOTH_HINT = 0x0C52;
const GL_POLYGON_SMOOTH_HINT = 0x0C53;
const GL_FOG_HINT = 0x0C54;
const GL_TEXTURE_GEN_S = 0x0C60;
const GL_TEXTURE_GEN_T = 0x0C61;
const GL_TEXTURE_GEN_R = 0x0C62;
const GL_TEXTURE_GEN_Q = 0x0C63;
const GL_PIXEL_MAP_I_TO_I = 0x0C70;
const GL_PIXEL_MAP_S_TO_S = 0x0C71;
const GL_PIXEL_MAP_I_TO_R = 0x0C72;
const GL_PIXEL_MAP_I_TO_G = 0x0C73;
const GL_PIXEL_MAP_I_TO_B = 0x0C74;
const GL_PIXEL_MAP_I_TO_A = 0x0C75;
const GL_PIXEL_MAP_R_TO_R = 0x0C76;
const GL_PIXEL_MAP_G_TO_G = 0x0C77;
const GL_PIXEL_MAP_B_TO_B = 0x0C78;
const GL_PIXEL_MAP_A_TO_A = 0x0C79;
const GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0;
const GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1;
const GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2;
const GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3;
const GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4;
const GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5;
const GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6;
const GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7;
const GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8;
const GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9;
const GL_UNPACK_SWAP_BYTES = 0x0CF0;
const GL_UNPACK_LSB_FIRST = 0x0CF1;
const GL_UNPACK_ROW_LENGTH = 0x0CF2;
const GL_UNPACK_SKIP_ROWS = 0x0CF3;
const GL_UNPACK_SKIP_PIXELS = 0x0CF4;
const GL_UNPACK_ALIGNMENT = 0x0CF5;
const GL_PACK_SWAP_BYTES = 0x0D00;
const GL_PACK_LSB_FIRST = 0x0D01;
const GL_PACK_ROW_LENGTH = 0x0D02;
const GL_PACK_SKIP_ROWS = 0x0D03;
const GL_PACK_SKIP_PIXELS = 0x0D04;
const GL_PACK_ALIGNMENT = 0x0D05;
const GL_MAP_COLOR = 0x0D10;
const GL_MAP_STENCIL = 0x0D11;
const GL_INDEX_SHIFT = 0x0D12;
const GL_INDEX_OFFSET = 0x0D13;
const GL_RED_SCALE = 0x0D14;
const GL_RED_BIAS = 0x0D15;
const GL_ZOOM_X = 0x0D16;
const GL_ZOOM_Y = 0x0D17;
const GL_GREEN_SCALE = 0x0D18;
const GL_GREEN_BIAS = 0x0D19;
const GL_BLUE_SCALE = 0x0D1A;
const GL_BLUE_BIAS = 0x0D1B;
const GL_ALPHA_SCALE = 0x0D1C;
const GL_ALPHA_BIAS = 0x0D1D;
const GL_DEPTH_SCALE = 0x0D1E;
const GL_DEPTH_BIAS = 0x0D1F;
const GL_MAX_EVAL_ORDER = 0x0D30;
const GL_MAX_LIGHTS = 0x0D31;
const GL_MAX_CLIP_PLANES = 0x0D32;
const GL_MAX_TEXTURE_SIZE = 0x0D33;
const GL_MAX_PIXEL_MAP_TABLE = 0x0D34;
const GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35;
const GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36;
const GL_MAX_NAME_STACK_DEPTH = 0x0D37;
const GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38;
const GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39;
const GL_MAX_VIEWPORT_DIMS = 0x0D3A;
const GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B;
const GL_SUBPIXEL_BITS = 0x0D50;
const GL_INDEX_BITS = 0x0D51;
const GL_RED_BITS = 0x0D52;
const GL_GREEN_BITS = 0x0D53;
const GL_BLUE_BITS = 0x0D54;
const GL_ALPHA_BITS = 0x0D55;
const GL_DEPTH_BITS = 0x0D56;
const GL_STENCIL_BITS = 0x0D57;
const GL_ACCUM_RED_BITS = 0x0D58;
const GL_ACCUM_GREEN_BITS = 0x0D59;
const GL_ACCUM_BLUE_BITS = 0x0D5A;
const GL_ACCUM_ALPHA_BITS = 0x0D5B;
const GL_NAME_STACK_DEPTH = 0x0D70;
const GL_AUTO_NORMAL = 0x0D80;
const GL_MAP1_COLOR_4 = 0x0D90;
const GL_MAP1_INDEX = 0x0D91;
const GL_MAP1_NORMAL = 0x0D92;
const GL_MAP1_TEXTURE_COORD_1 = 0x0D93;
const GL_MAP1_TEXTURE_COORD_2 = 0x0D94;
const GL_MAP1_TEXTURE_COORD_3 = 0x0D95;
const GL_MAP1_TEXTURE_COORD_4 = 0x0D96;
const GL_MAP1_VERTEX_3 = 0x0D97;
const GL_MAP1_VERTEX_4 = 0x0D98;
const GL_MAP2_COLOR_4 = 0x0DB0;
const GL_MAP2_INDEX = 0x0DB1;
const GL_MAP2_NORMAL = 0x0DB2;
const GL_MAP2_TEXTURE_COORD_1 = 0x0DB3;
const GL_MAP2_TEXTURE_COORD_2 = 0x0DB4;
const GL_MAP2_TEXTURE_COORD_3 = 0x0DB5;
const GL_MAP2_TEXTURE_COORD_4 = 0x0DB6;
const GL_MAP2_VERTEX_3 = 0x0DB7;
const GL_MAP2_VERTEX_4 = 0x0DB8;
const GL_MAP1_GRID_DOMAIN = 0x0DD0;
const GL_MAP1_GRID_SEGMENTS = 0x0DD1;
const GL_MAP2_GRID_DOMAIN = 0x0DD2;
const GL_MAP2_GRID_SEGMENTS = 0x0DD3;
const GL_TEXTURE_1D = 0x0DE0;
const GL_TEXTURE_2D = 0x0DE1;
const GL_FEEDBACK_BUFFER_POINTER = 0x0DF0;
const GL_FEEDBACK_BUFFER_SIZE = 0x0DF1;
const GL_FEEDBACK_BUFFER_TYPE = 0x0DF2;
const GL_SELECTION_BUFFER_POINTER = 0x0DF3;
/* GL_TEXTURE_BINDING_1D */
const GL_SELECTION_BUFFER_SIZE = 0x0DF4;
/* GL_TEXTURE_BINDING_2D */
/* GL_VERTEX_ARRAY */
/* GL_NORMAL_ARRAY */
/* GL_COLOR_ARRAY */
/* GL_INDEX_ARRAY */
/* GL_TEXTURE_COORD_ARRAY */
/* GL_EDGE_FLAG_ARRAY */
/* GL_VERTEX_ARRAY_SIZE */
/* GL_VERTEX_ARRAY_TYPE */
/* GL_VERTEX_ARRAY_STRIDE */
/* GL_NORMAL_ARRAY_TYPE */
/* GL_NORMAL_ARRAY_STRIDE */
/* GL_COLOR_ARRAY_SIZE */
/* GL_COLOR_ARRAY_TYPE */
/* GL_COLOR_ARRAY_STRIDE */
/* GL_INDEX_ARRAY_TYPE */
/* GL_INDEX_ARRAY_STRIDE */
/* GL_TEXTURE_COORD_ARRAY_SIZE */
/* GL_TEXTURE_COORD_ARRAY_TYPE */
/* GL_TEXTURE_COORD_ARRAY_STRIDE */
/* GL_EDGE_FLAG_ARRAY_STRIDE */
/* GL_POLYGON_OFFSET_FACTOR */
/* GL_POLYGON_OFFSET_UNITS */
/* GetTextureParameter */
/* GL_TEXTURE_MAG_FILTER */
/* GL_TEXTURE_MIN_FILTER */
/* GL_TEXTURE_WRAP_S */
/* GL_TEXTURE_WRAP_T */
const GL_TEXTURE_WIDTH = 0x1000;
const GL_TEXTURE_HEIGHT = 0x1001;
const GL_TEXTURE_INTERNAL_FORMAT = 0x1003;
const GL_TEXTURE_BORDER_COLOR = 0x1004;
/* GL_TEXTURE_RED_SIZE */
const GL_TEXTURE_BORDER = 0x1005;
/* GL_TEXTURE_GREEN_SIZE */
/* GL_TEXTURE_BLUE_SIZE */
/* GL_TEXTURE_ALPHA_SIZE */
/* GL_TEXTURE_LUMINANCE_SIZE */
/* GL_TEXTURE_INTENSITY_SIZE */
/* GL_TEXTURE_PRIORITY */
/* GL_TEXTURE_RESIDENT */
/* HintMode */
const GL_DONT_CARE = 0x1100;
const GL_FASTEST = 0x1101;
const GL_NICEST = 0x1102;
/* HintTarget */
/* GL_PERSPECTIVE_CORRECTION_HINT */
/* GL_POINT_SMOOTH_HINT */
/* GL_LINE_SMOOTH_HINT */
/* GL_POLYGON_SMOOTH_HINT */
/* GL_FOG_HINT */
/* GL_PHONG_HINT */
/* IndexPointerType */
/* GL_SHORT */
/* GL_INT */
/* GL_FLOAT */
/* GL_DOUBLE */
/* LightModelParameter */
/* GL_LIGHT_MODEL_AMBIENT */
/* GL_LIGHT_MODEL_LOCAL_VIEWER */
/* GL_LIGHT_MODEL_TWO_SIDE */
/* LightName */
const GL_LIGHT0 = 0x4000;
const GL_LIGHT1 = 0x4001;
const GL_LIGHT2 = 0x4002;
const GL_LIGHT3 = 0x4003;
const GL_LIGHT4 = 0x4004;
const GL_LIGHT5 = 0x4005;
const GL_LIGHT6 = 0x4006;
const GL_LIGHT7 = 0x4007;
/* LightParameter */
const GL_AMBIENT = 0x1200;
const GL_DIFFUSE = 0x1201;
const GL_SPECULAR = 0x1202;
const GL_POSITION = 0x1203;
const GL_SPOT_DIRECTION = 0x1204;
const GL_SPOT_EXPONENT = 0x1205;
const GL_SPOT_CUTOFF = 0x1206;
const GL_CONSTANT_ATTENUATION = 0x1207;
const GL_LINEAR_ATTENUATION = 0x1208;
const GL_QUADRATIC_ATTENUATION = 0x1209;
/* InterleavedArrays */
/* GL_V2F */
/* GL_V3F */
/* GL_C4UB_V2F */
/* GL_C4UB_V3F */
/* GL_C3F_V3F */
/* GL_N3F_V3F */
/* GL_C4F_N3F_V3F */
/* GL_T2F_V3F */
/* GL_T4F_V4F */
/* GL_T2F_C4UB_V3F */
/* GL_T2F_C3F_V3F */
/* GL_T2F_N3F_V3F */
/* GL_T2F_C4F_N3F_V3F */
/* GL_T4F_C4F_N3F_V4F */
/* ListMode */
const GL_COMPILE = 0x1300;
const GL_COMPILE_AND_EXECUTE = 0x1301;
/* ListNameType */
/* GL_BYTE */
/* GL_UNSIGNED_BYTE */
/* GL_SHORT */
/* GL_UNSIGNED_SHORT */
/* GL_INT */
/* GL_UNSIGNED_INT */
/* GL_FLOAT */
/* GL_2_BYTES */
/* GL_3_BYTES */
/* GL_4_BYTES */
/* LogicOp */
const GL_CLEAR = 0x1500;
const GL_AND = 0x1501;
const GL_AND_REVERSE = 0x1502;
const GL_COPY = 0x1503;
const GL_AND_INVERTED = 0x1504;
const GL_NOOP = 0x1505;
const GL_XOR = 0x1506;
const GL_OR = 0x1507;
const GL_NOR = 0x1508;
const GL_EQUIV = 0x1509;
const GL_INVERT = 0x150A;
const GL_OR_REVERSE = 0x150B;
const GL_COPY_INVERTED = 0x150C;
const GL_OR_INVERTED = 0x150D;
const GL_NAND = 0x150E;
const GL_SET = 0x150F;
/* MapTarget */
/* GL_MAP1_COLOR_4 */
/* GL_MAP1_INDEX */
/* GL_MAP1_NORMAL */
/* GL_MAP1_TEXTURE_COORD_1 */
/* GL_MAP1_TEXTURE_COORD_2 */
/* GL_MAP1_TEXTURE_COORD_3 */
/* GL_MAP1_TEXTURE_COORD_4 */
/* GL_MAP1_VERTEX_3 */
/* GL_MAP1_VERTEX_4 */
/* GL_MAP2_COLOR_4 */
/* GL_MAP2_INDEX */
/* GL_MAP2_NORMAL */
/* GL_MAP2_TEXTURE_COORD_1 */
/* GL_MAP2_TEXTURE_COORD_2 */
/* GL_MAP2_TEXTURE_COORD_3 */
/* GL_MAP2_TEXTURE_COORD_4 */
/* GL_MAP2_VERTEX_3 */
/* GL_MAP2_VERTEX_4 */
/* MaterialFace */
/* GL_FRONT */
/* GL_BACK */
/* GL_FRONT_AND_BACK */
/* MaterialParameter */
const GL_EMISSION = 0x1600;
const GL_SHININESS = 0x1601;
const GL_AMBIENT_AND_DIFFUSE = 0x1602;
/* GL_AMBIENT */
const GL_COLOR_INDEXES = 0x1603;
/* GL_DIFFUSE */
/* GL_SPECULAR */
/* MatrixMode */
const GL_MODELVIEW = 0x1700;
const GL_PROJECTION = 0x1701;
const GL_TEXTURE = 0x1702;
/* MeshMode1 */
/* GL_POINT */
/* GL_LINE */
/* MeshMode2 */
/* GL_POINT */
/* GL_LINE */
/* GL_FILL */
/* NormalPointerType */
/* GL_BYTE */
/* GL_SHORT */
/* GL_INT */
/* GL_FLOAT */
/* GL_DOUBLE */
/* PixelCopyType */
const GL_COLOR = 0x1800;
const GL_DEPTH = 0x1801;
const GL_STENCIL = 0x1802;
/* PixelFormat */
const GL_COLOR_INDEX = 0x1900;
const GL_STENCIL_INDEX = 0x1901;
const GL_DEPTH_COMPONENT = 0x1902;
const GL_RED = 0x1903;
const GL_GREEN = 0x1904;
const GL_BLUE = 0x1905;
const GL_ALPHA = 0x1906;
const GL_RGB = 0x1907;
const GL_RGBA = 0x1908;
const GL_LUMINANCE = 0x1909;
const GL_LUMINANCE_ALPHA = 0x190A;
/* PixelMap */
/* GL_PIXEL_MAP_I_TO_I */
/* GL_PIXEL_MAP_S_TO_S */
/* GL_PIXEL_MAP_I_TO_R */
/* GL_PIXEL_MAP_I_TO_G */
/* GL_PIXEL_MAP_I_TO_B */
/* GL_PIXEL_MAP_I_TO_A */
/* GL_PIXEL_MAP_R_TO_R */
/* GL_PIXEL_MAP_G_TO_G */
/* GL_PIXEL_MAP_B_TO_B */
/* GL_PIXEL_MAP_A_TO_A */
/* PixelStore */
/* GL_UNPACK_SWAP_BYTES */
/* GL_UNPACK_LSB_FIRST */
/* GL_UNPACK_ROW_LENGTH */
/* GL_UNPACK_SKIP_ROWS */
/* GL_UNPACK_SKIP_PIXELS */
/* GL_UNPACK_ALIGNMENT */
/* GL_PACK_SWAP_BYTES */
/* GL_PACK_LSB_FIRST */
/* GL_PACK_ROW_LENGTH */
/* GL_PACK_SKIP_ROWS */
/* GL_PACK_SKIP_PIXELS */
/* GL_PACK_ALIGNMENT */
/* PixelTransfer */
/* GL_MAP_COLOR */
/* GL_MAP_STENCIL */
/* GL_INDEX_SHIFT */
/* GL_INDEX_OFFSET */
/* GL_RED_SCALE */
/* GL_RED_BIAS */
/* GL_GREEN_SCALE */
/* GL_GREEN_BIAS */
/* GL_BLUE_SCALE */
/* GL_BLUE_BIAS */
/* GL_ALPHA_SCALE */
/* GL_ALPHA_BIAS */
/* GL_DEPTH_SCALE */
/* GL_DEPTH_BIAS */
/* PixelType */
/* GL_BYTE */
const GL_BITMAP = 0x1A00;
/* GL_UNSIGNED_BYTE */
/* GL_SHORT */
/* GL_UNSIGNED_SHORT */
/* GL_INT */
/* GL_UNSIGNED_INT */
/* GL_FLOAT */
/* PolygonMode */
const GL_POINT = 0x1B00;
const GL_LINE = 0x1B01;
const GL_FILL = 0x1B02;
/* ReadBufferMode */
/* GL_FRONT_LEFT */
/* GL_FRONT_RIGHT */
/* GL_BACK_LEFT */
/* GL_BACK_RIGHT */
/* GL_FRONT */
/* GL_BACK */
/* GL_LEFT */
/* GL_RIGHT */
/* GL_AUX0 */
/* GL_AUX1 */
/* GL_AUX2 */
/* GL_AUX3 */
/* RenderingMode */
const GL_RENDER = 0x1C00;
const GL_FEEDBACK = 0x1C01;
const GL_SELECT = 0x1C02;
/* ShadingModel */
const GL_FLAT = 0x1D00;
const GL_SMOOTH = 0x1D01;
/* StencilFunction */
/* GL_NEVER */
/* GL_LESS */
/* GL_EQUAL */
/* GL_LEQUAL */
/* GL_GREATER */
/* GL_NOTEQUAL */
/* GL_GEQUAL */
/* GL_ALWAYS */
/* StencilOp */
/* GL_ZERO */
const GL_KEEP = 0x1E00;
const GL_REPLACE = 0x1E01;
const GL_INCR = 0x1E02;
/* GL_INVERT */
const GL_DECR = 0x1E03;
/* StringName */
const GL_VENDOR = 0x1F00;
const GL_RENDERER = 0x1F01;
const GL_VERSION = 0x1F02;
const GL_EXTENSIONS = 0x1F03;
/* TextureCoordName */
const GL_S = 0x2000;
const GL_T = 0x2001;
const GL_R = 0x2002;
const GL_Q = 0x2003;
/* TexCoordPointerType */
/* GL_SHORT */
/* GL_INT */
/* GL_FLOAT */
/* GL_DOUBLE */
/* TextureEnvMode */
const GL_MODULATE = 0x2100;
/* GL_BLEND */
const GL_DECAL = 0x2101;
/* GL_REPLACE */
/* TextureEnvParameter */
const GL_TEXTURE_ENV_MODE = 0x2200;
const GL_TEXTURE_ENV_COLOR = 0x2201;
/* TextureEnvTarget */
const GL_TEXTURE_ENV = 0x2300;
/* TextureGenMode */
const GL_EYE_LINEAR = 0x2400;
const GL_OBJECT_LINEAR = 0x2401;
const GL_SPHERE_MAP = 0x2402;
/* TextureGenParameter */
const GL_TEXTURE_GEN_MODE = 0x2500;
const GL_OBJECT_PLANE = 0x2501;
const GL_EYE_PLANE = 0x2502;
/* TextureMagFilter */
const GL_NEAREST = 0x2600;
const GL_LINEAR = 0x2601;
/* TextureMinFilter */
/* GL_NEAREST */
/* GL_LINEAR */
const GL_NEAREST_MIPMAP_NEAREST = 0x2700;
const GL_LINEAR_MIPMAP_NEAREST = 0x2701;
const GL_NEAREST_MIPMAP_LINEAR = 0x2702;
const GL_LINEAR_MIPMAP_LINEAR = 0x2703;
/* TextureParameterName */
const GL_TEXTURE_MAG_FILTER = 0x2800;
const GL_TEXTURE_MIN_FILTER = 0x2801;
const GL_TEXTURE_WRAP_S = 0x2802;
/* GL_TEXTURE_BORDER_COLOR */
const GL_TEXTURE_WRAP_T = 0x2803;
/* GL_TEXTURE_PRIORITY */
/* TextureTarget */
/* GL_TEXTURE_1D */
/* GL_TEXTURE_2D */
/* GL_PROXY_TEXTURE_1D */
/* GL_PROXY_TEXTURE_2D */
/* TextureWrapMode */
const GL_CLAMP = 0x2900;
const GL_REPEAT = 0x2901;
/* VertexPointerType */
/* GL_SHORT */
/* GL_INT */
/* GL_FLOAT */
/* GL_DOUBLE */
/* ClientAttribMask */
const GL_CLIENT_PIXEL_STORE_BIT = 0x00000001;
const GL_CLIENT_VERTEX_ARRAY_BIT = 0x00000002;
const GL_CLIENT_ALL_ATTRIB_BITS = 0xffffffff;
/* polygon_offset */
const GL_POLYGON_OFFSET_FACTOR = 0x8038;
const GL_POLYGON_OFFSET_UNITS = 0x2A00;
const GL_POLYGON_OFFSET_POINT = 0x2A01;
const GL_POLYGON_OFFSET_LINE = 0x2A02;
const GL_POLYGON_OFFSET_FILL = 0x8037;
/* texture */
const GL_ALPHA4 = 0x803B;
const GL_ALPHA8 = 0x803C;
const GL_ALPHA12 = 0x803D;
const GL_ALPHA16 = 0x803E;
const GL_LUMINANCE4 = 0x803F;
const GL_LUMINANCE8 = 0x8040;
const GL_LUMINANCE12 = 0x8041;
const GL_LUMINANCE16 = 0x8042;
const GL_LUMINANCE4_ALPHA4 = 0x8043;
const GL_LUMINANCE6_ALPHA2 = 0x8044;
const GL_LUMINANCE8_ALPHA8 = 0x8045;
const GL_LUMINANCE12_ALPHA4 = 0x8046;
const GL_LUMINANCE12_ALPHA12 = 0x8047;
const GL_LUMINANCE16_ALPHA16 = 0x8048;
const GL_INTENSITY = 0x8049;
const GL_INTENSITY4 = 0x804A;
const GL_INTENSITY8 = 0x804B;
const GL_INTENSITY12 = 0x804C;
const GL_INTENSITY16 = 0x804D;
const GL_R3_G3_B2 = 0x2A10;
const GL_RGB4 = 0x804F;
const GL_RGB5 = 0x8050;
const GL_RGB8 = 0x8051;
const GL_RGB10 = 0x8052;
const GL_RGB12 = 0x8053;
const GL_RGB16 = 0x8054;
const GL_RGBA2 = 0x8055;
const GL_RGBA4 = 0x8056;
const GL_RGB5_A1 = 0x8057;
const GL_RGBA8 = 0x8058;
const GL_RGB10_A2 = 0x8059;
const GL_RGBA12 = 0x805A;
const GL_RGBA16 = 0x805B;
const GL_TEXTURE_RED_SIZE = 0x805C;
const GL_TEXTURE_GREEN_SIZE = 0x805D;
const GL_TEXTURE_BLUE_SIZE = 0x805E;
const GL_TEXTURE_ALPHA_SIZE = 0x805F;
const GL_TEXTURE_LUMINANCE_SIZE = 0x8060;
const GL_TEXTURE_INTENSITY_SIZE = 0x8061;
const GL_PROXY_TEXTURE_1D = 0x8063;
const GL_PROXY_TEXTURE_2D = 0x8064;
/* texture_object */
const GL_TEXTURE_PRIORITY = 0x8066;
const GL_TEXTURE_RESIDENT = 0x8067;
const GL_TEXTURE_BINDING_1D = 0x8068;
const GL_TEXTURE_BINDING_2D = 0x8069;
/* vertex_array */
const GL_VERTEX_ARRAY = 0x8074;
const GL_NORMAL_ARRAY = 0x8075;
const GL_COLOR_ARRAY = 0x8076;
const GL_INDEX_ARRAY = 0x8077;
const GL_TEXTURE_COORD_ARRAY = 0x8078;
const GL_EDGE_FLAG_ARRAY = 0x8079;
const GL_VERTEX_ARRAY_SIZE = 0x807A;
const GL_VERTEX_ARRAY_TYPE = 0x807B;
const GL_VERTEX_ARRAY_STRIDE = 0x807C;
const GL_NORMAL_ARRAY_TYPE = 0x807E;
const GL_NORMAL_ARRAY_STRIDE = 0x807F;
const GL_COLOR_ARRAY_SIZE = 0x8081;
const GL_COLOR_ARRAY_TYPE = 0x8082;
const GL_COLOR_ARRAY_STRIDE = 0x8083;
const GL_INDEX_ARRAY_TYPE = 0x8085;
const GL_INDEX_ARRAY_STRIDE = 0x8086;
const GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088;
const GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089;
const GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A;
const GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C;
const GL_VERTEX_ARRAY_POINTER = 0x808E;
const GL_NORMAL_ARRAY_POINTER = 0x808F;
const GL_COLOR_ARRAY_POINTER = 0x8090;
const GL_INDEX_ARRAY_POINTER = 0x8091;
const GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092;
const GL_EDGE_FLAG_ARRAY_POINTER = 0x8093;
const GL_V2F = 0x2A20;
const GL_V3F = 0x2A21;
const GL_C4UB_V2F = 0x2A22;
const GL_C4UB_V3F = 0x2A23;
const GL_C3F_V3F = 0x2A24;
const GL_N3F_V3F = 0x2A25;
const GL_C4F_N3F_V3F = 0x2A26;
const GL_T2F_V3F = 0x2A27;
const GL_T4F_V4F = 0x2A28;
const GL_T2F_C4UB_V3F = 0x2A29;
const GL_T2F_C3F_V3F = 0x2A2A;
const GL_T2F_N3F_V3F = 0x2A2B;
const GL_T2F_C4F_N3F_V3F = 0x2A2C;
const GL_T4F_C4F_N3F_V4F = 0x2A2D;
/* Extensions */
const GL_EXT_vertex_array = 1;
const GL_EXT_bgra = 1;
const GL_EXT_paletted_texture = 1;
const GL_WIN_swap_hint = 1;
// #define GL_WIN_phong_shading 1
const GL_WIN_draw_range_elements = 1;
// #define GL_WIN_specular_fog 1
/* EXT_vertex_array */
const GL_VERTEX_ARRAY_EXT = 0x8074;
const GL_NORMAL_ARRAY_EXT = 0x8075;
const GL_COLOR_ARRAY_EXT = 0x8076;
const GL_INDEX_ARRAY_EXT = 0x8077;
const GL_TEXTURE_COORD_ARRAY_EXT = 0x8078;
const GL_EDGE_FLAG_ARRAY_EXT = 0x8079;
const GL_VERTEX_ARRAY_SIZE_EXT = 0x807A;
const GL_VERTEX_ARRAY_TYPE_EXT = 0x807B;
const GL_VERTEX_ARRAY_STRIDE_EXT = 0x807C;
const GL_VERTEX_ARRAY_COUNT_EXT = 0x807D;
const GL_NORMAL_ARRAY_TYPE_EXT = 0x807E;
const GL_NORMAL_ARRAY_STRIDE_EXT = 0x807F;
const GL_NORMAL_ARRAY_COUNT_EXT = 0x8080;
const GL_COLOR_ARRAY_SIZE_EXT = 0x8081;
const GL_COLOR_ARRAY_TYPE_EXT = 0x8082;
const GL_COLOR_ARRAY_STRIDE_EXT = 0x8083;
const GL_COLOR_ARRAY_COUNT_EXT = 0x8084;
const GL_INDEX_ARRAY_TYPE_EXT = 0x8085;
const GL_INDEX_ARRAY_STRIDE_EXT = 0x8086;
const GL_INDEX_ARRAY_COUNT_EXT = 0x8087;
const GL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088;
const GL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089;
const GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A;
const GL_TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B;
const GL_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C;
const GL_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D;
const GL_VERTEX_ARRAY_POINTER_EXT = 0x808E;
const GL_NORMAL_ARRAY_POINTER_EXT = 0x808F;
const GL_COLOR_ARRAY_POINTER_EXT = 0x8090;
const GL_INDEX_ARRAY_POINTER_EXT = 0x8091;
const GL_TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092;
const GL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093;
alias GL_DOUBLE GL_DOUBLE_EXT;
/* EXT_bgra */
const GL_BGR_EXT = 0x80E0;
const GL_BGRA_EXT = 0x80E1;
/* EXT_paletted_texture */
/* These must match the GL_COLOR_TABLE_*_SGI enumerants */
const GL_COLOR_TABLE_FORMAT_EXT = 0x80D8;
const GL_COLOR_TABLE_WIDTH_EXT = 0x80D9;
const GL_COLOR_TABLE_RED_SIZE_EXT = 0x80DA;
const GL_COLOR_TABLE_GREEN_SIZE_EXT = 0x80DB;
const GL_COLOR_TABLE_BLUE_SIZE_EXT = 0x80DC;
const GL_COLOR_TABLE_ALPHA_SIZE_EXT = 0x80DD;
const GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = 0x80DE;
const GL_COLOR_TABLE_INTENSITY_SIZE_EXT = 0x80DF;
const GL_COLOR_INDEX1_EXT = 0x80E2;
const GL_COLOR_INDEX2_EXT = 0x80E3;
const GL_COLOR_INDEX4_EXT = 0x80E4;
const GL_COLOR_INDEX8_EXT = 0x80E5;
const GL_COLOR_INDEX12_EXT = 0x80E6;
const GL_COLOR_INDEX16_EXT = 0x80E7;
/* WIN_draw_range_elements */
const GL_MAX_ELEMENTS_VERTICES_WIN = 0x80E8;
const GL_MAX_ELEMENTS_INDICES_WIN = 0x80E9;
/* WIN_phong_shading */
const GL_PHONG_WIN = 0x80EA;
const GL_PHONG_HINT_WIN = 0x80EB;
/* WIN_specular_fog */
const GL_FOG_SPECULAR_TEXTURE_WIN = 0x80EC;
/* For compatibility with OpenGL v1.0 */
alias GL_INDEX_LOGIC_OP GL_LOGIC_OP;
alias GL_TEXTURE_INTERNAL_FORMAT GL_TEXTURE_COMPONENTS;
/*************************************************************/
/* EXT_vertex_array */
alias void function(GLint i)PFNGLARRAYELEMENTEXTPROC;
alias void function(GLenum mode, GLint first, GLsizei count)PFNGLDRAWARRAYSEXTPROC;
alias void function(GLint size, GLenum type, GLsizei stride, GLsizei count, GLvoid *pointer)PFNGLVERTEXPOINTEREXTPROC;
alias void function(GLenum type, GLsizei stride, GLsizei count, GLvoid *pointer)PFNGLNORMALPOINTEREXTPROC;
alias void function(GLint size, GLenum type, GLsizei stride, GLsizei count, GLvoid *pointer)PFNGLCOLORPOINTEREXTPROC;
alias void function(GLenum type, GLsizei stride, GLsizei count, GLvoid *pointer)PFNGLINDEXPOINTEREXTPROC;
alias void function(GLint size, GLenum type, GLsizei stride, GLsizei count, GLvoid *pointer)PFNGLTEXCOORDPOINTEREXTPROC;
alias void function(GLsizei stride, GLsizei count, GLboolean *pointer)PFNGLEDGEFLAGPOINTEREXTPROC;
alias void function(GLenum pname, GLvoid **params)PFNGLGETPOINTERVEXTPROC;
alias void function(GLenum mode, GLsizei count, GLvoid *pi)PFNGLARRAYELEMENTARRAYEXTPROC;
/* WIN_draw_range_elements */
alias void function(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLvoid *indices)PFNGLDRAWRANGEELEMENTSWINPROC;
/* WIN_swap_hint */
alias void function(GLint x, GLint y, GLsizei width, GLsizei height)PFNGLADDSWAPHINTRECTWINPROC;
/* EXT_paletted_texture */
alias void function(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, GLvoid *data)PFNGLCOLORTABLEEXTPROC;
alias void function(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, GLvoid *data)PFNGLCOLORSUBTABLEEXTPROC;
alias void function(GLenum target, GLenum format, GLenum type, GLvoid *data)PFNGLGETCOLORTABLEEXTPROC;
alias void function(GLenum target, GLenum pname, GLint *params)PFNGLGETCOLORTABLEPARAMETERIVEXTPROC;
alias void function(GLenum target, GLenum pname, GLfloat *params)PFNGLGETCOLORTABLEPARAMETERFVEXTPROC;
|
D
|
// Written in the D programming language.
/**
Standard I/O functions that extend $(B core.stdc.stdio). $(B core.stdc.stdio)
is $(D_PARAM public)ally imported when importing $(B std.stdio).
Source: $(PHOBOSSRC std/_stdio.d)
Copyright: Copyright Digital Mars 2007-.
License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
Authors: $(HTTP digitalmars.com, Walter Bright),
$(HTTP erdani.org, Andrei Alexandrescu),
Alex Rønne Petersen
*/
module std.stdio;
import core.stdc.stddef; // wchar_t
public import core.stdc.stdio;
import std.algorithm.mutation; // copy
import std.meta; // allSatisfy
import std.range.primitives; // ElementEncodingType, empty, front,
// isBidirectionalRange, isInputRange, put
import std.traits; // isSomeChar, isSomeString, Unqual, isPointer
import std.typecons; // Flag
/++
If flag $(D KeepTerminator) is set to $(D KeepTerminator.yes), then the delimiter
is included in the strings returned.
+/
alias KeepTerminator = Flag!"keepTerminator";
version (CRuntime_Microsoft)
{
version = MICROSOFT_STDIO;
}
else version (CRuntime_DigitalMars)
{
// Specific to the way Digital Mars C does stdio
version = DIGITAL_MARS_STDIO;
}
version (CRuntime_Glibc)
{
// Specific to the way Gnu C does stdio
version = GCC_IO;
version = HAS_GETDELIM;
}
else version (CRuntime_Bionic)
{
version = GENERIC_IO;
version = HAS_GETDELIM;
}
else version (CRuntime_Musl)
{
version = GENERIC_IO;
version = HAS_GETDELIM;
}
else version (CRuntime_UClibc)
{
// uClibc supports GCC IO
version = GCC_IO;
version = HAS_GETDELIM;
}
version (OSX)
{
version = GENERIC_IO;
version = HAS_GETDELIM;
}
else version (FreeBSD)
{
version = GENERIC_IO;
version = HAS_GETDELIM;
}
else version (NetBSD)
{
version = GENERIC_IO;
version = HAS_GETDELIM;
}
else version (DragonFlyBSD)
{
version = GENERIC_IO;
version = HAS_GETDELIM;
}
else version (Solaris)
{
version = GENERIC_IO;
version = NO_GETDELIM;
}
// Character type used for operating system filesystem APIs
version (Windows)
{
private alias FSChar = wchar;
}
else version (Posix)
{
private alias FSChar = char;
}
else
static assert(0);
version(Windows)
{
// core.stdc.stdio.fopen expects file names to be
// encoded in CP_ACP on Windows instead of UTF-8.
/+ Waiting for druntime pull 299
+/
extern (C) nothrow @nogc FILE* _wfopen(in wchar* filename, in wchar* mode);
extern (C) nothrow @nogc FILE* _wfreopen(in wchar* filename, in wchar* mode, FILE* fp);
import core.sys.windows.windows : HANDLE;
}
version (DIGITAL_MARS_STDIO)
{
extern (C)
{
/* **
* Digital Mars under-the-hood C I/O functions.
* Use _iobuf* for the unshared version of FILE*,
* usable when the FILE is locked.
*/
nothrow:
@nogc:
int _fputc_nlock(int, _iobuf*);
int _fputwc_nlock(int, _iobuf*);
int _fgetc_nlock(_iobuf*);
int _fgetwc_nlock(_iobuf*);
int __fp_lock(FILE*);
void __fp_unlock(FILE*);
int setmode(int, int);
}
alias FPUTC = _fputc_nlock;
alias FPUTWC = _fputwc_nlock;
alias FGETC = _fgetc_nlock;
alias FGETWC = _fgetwc_nlock;
alias FLOCK = __fp_lock;
alias FUNLOCK = __fp_unlock;
alias _setmode = setmode;
enum _O_BINARY = 0x8000;
int _fileno(FILE* f) { return f._file; }
alias fileno = _fileno;
}
else version (MICROSOFT_STDIO)
{
extern (C)
{
/* **
* Microsoft under-the-hood C I/O functions
*/
nothrow:
@nogc:
int _fputc_nolock(int, _iobuf*);
int _fputwc_nolock(int, _iobuf*);
int _fgetc_nolock(_iobuf*);
int _fgetwc_nolock(_iobuf*);
void _lock_file(FILE*);
void _unlock_file(FILE*);
int _setmode(int, int);
int _fileno(FILE*);
FILE* _fdopen(int, const (char)*);
int _fseeki64(FILE*, long, int);
long _ftelli64(FILE*);
}
alias FPUTC = _fputc_nolock;
alias FPUTWC = _fputwc_nolock;
alias FGETC = _fgetc_nolock;
alias FGETWC = _fgetwc_nolock;
alias FLOCK = _lock_file;
alias FUNLOCK = _unlock_file;
alias setmode = _setmode;
alias fileno = _fileno;
enum
{
_O_RDONLY = 0x0000,
_O_APPEND = 0x0004,
_O_TEXT = 0x4000,
_O_BINARY = 0x8000,
}
}
else version (GCC_IO)
{
/* **
* Gnu under-the-hood C I/O functions; see
* http://gnu.org/software/libc/manual/html_node/I_002fO-on-Streams.html
*/
extern (C)
{
nothrow:
@nogc:
int fputc_unlocked(int, _iobuf*);
int fputwc_unlocked(wchar_t, _iobuf*);
int fgetc_unlocked(_iobuf*);
int fgetwc_unlocked(_iobuf*);
void flockfile(FILE*);
void funlockfile(FILE*);
private size_t fwrite_unlocked(const(void)* ptr,
size_t size, size_t n, _iobuf *stream);
}
alias FPUTC = fputc_unlocked;
alias FPUTWC = fputwc_unlocked;
alias FGETC = fgetc_unlocked;
alias FGETWC = fgetwc_unlocked;
alias FLOCK = flockfile;
alias FUNLOCK = funlockfile;
}
else version (GENERIC_IO)
{
nothrow:
@nogc:
extern (C)
{
void flockfile(FILE*);
void funlockfile(FILE*);
}
int fputc_unlocked(int c, _iobuf* fp) { return fputc(c, cast(shared) fp); }
int fputwc_unlocked(wchar_t c, _iobuf* fp)
{
import core.stdc.wchar_ : fputwc;
return fputwc(c, cast(shared) fp);
}
int fgetc_unlocked(_iobuf* fp) { return fgetc(cast(shared) fp); }
int fgetwc_unlocked(_iobuf* fp)
{
import core.stdc.wchar_ : fgetwc;
return fgetwc(cast(shared) fp);
}
alias FPUTC = fputc_unlocked;
alias FPUTWC = fputwc_unlocked;
alias FGETC = fgetc_unlocked;
alias FGETWC = fgetwc_unlocked;
alias FLOCK = flockfile;
alias FUNLOCK = funlockfile;
}
else
{
static assert(0, "unsupported C I/O system");
}
version(HAS_GETDELIM) extern(C) nothrow @nogc
{
ptrdiff_t getdelim(char**, size_t*, int, FILE*);
// getline() always comes together with getdelim()
ptrdiff_t getline(char**, size_t*, FILE*);
}
//------------------------------------------------------------------------------
private struct ByRecordImpl(Fields...)
{
private:
import std.typecons : Tuple;
File file;
char[] line;
Tuple!(Fields) current;
string format;
public:
this(File f, string format)
{
assert(f.isOpen);
file = f;
this.format = format;
popFront(); // prime the range
}
/// Range primitive implementations.
@property bool empty()
{
return !file.isOpen;
}
/// Ditto
@property ref Tuple!(Fields) front()
{
return current;
}
/// Ditto
void popFront()
{
import std.conv : text;
import std.exception : enforce;
import std.format : formattedRead;
import std.string : chomp;
enforce(file.isOpen, "ByRecord: File must be open");
file.readln(line);
if (!line.length)
{
file.detach();
}
else
{
line = chomp(line);
formattedRead(line, format, ¤t);
enforce(line.empty, text("Leftover characters in record: `",
line, "'"));
}
}
}
// @@@DEPRECATED_2019-01@@@
deprecated("Use .byRecord")
struct ByRecord(Fields...)
{
ByRecordImpl!Fields payload;
alias payload this;
}
template byRecord(Fields...)
{
auto byRecord(File f, string format)
{
return typeof(return)(f, format);
}
}
/**
Encapsulates a $(D FILE*). Generally D does not attempt to provide
thin wrappers over equivalent functions in the C standard library, but
manipulating $(D FILE*) values directly is unsafe and error-prone in
many ways. The $(D File) type ensures safe manipulation, automatic
file closing, and a lot of convenience.
The underlying $(D FILE*) handle is maintained in a reference-counted
manner, such that as soon as the last $(D File) variable bound to a
given $(D FILE*) goes out of scope, the underlying $(D FILE*) is
automatically closed.
Example:
----
// test.d
void main(string[] args)
{
auto f = File("test.txt", "w"); // open for writing
f.write("Hello");
if (args.length > 1)
{
auto g = f; // now g and f write to the same file
// internal reference count is 2
g.write(", ", args[1]);
// g exits scope, reference count decreases to 1
}
f.writeln("!");
// f exits scope, reference count falls to zero,
// underlying `FILE*` is closed.
}
----
$(CONSOLE
% rdmd test.d Jimmy
% cat test.txt
Hello, Jimmy!
% __
)
*/
struct File
{
import std.range.primitives : ElementEncodingType;
import std.traits : isScalarType, isArray;
enum Orientation { unknown, narrow, wide }
private struct Impl
{
FILE * handle = null; // Is null iff this Impl is closed by another File
uint refs = uint.max / 2;
bool isPopened; // true iff the stream has been created by popen()
Orientation orientation;
}
private Impl* _p;
private string _name;
package this(FILE* handle, string name, uint refs = 1, bool isPopened = false) @trusted
{
import core.stdc.stdlib : malloc;
import std.exception : enforce;
assert(!_p);
_p = cast(Impl*) enforce(malloc(Impl.sizeof), "Out of memory");
initImpl(handle, name, refs, isPopened);
}
private void initImpl(FILE* handle, string name, uint refs = 1, bool isPopened = false)
{
assert(_p);
_p.handle = handle;
_p.refs = refs;
_p.isPopened = isPopened;
_p.orientation = Orientation.unknown;
_name = name;
}
/**
Constructor taking the name of the file to open and the open mode.
Copying one $(D File) object to another results in the two $(D File)
objects referring to the same underlying file.
The destructor automatically closes the file as soon as no $(D File)
object refers to it anymore.
Params:
name = range or string representing the file _name
stdioOpenmode = range or string represting the open mode
(with the same semantics as in the C standard library
$(HTTP cplusplus.com/reference/clibrary/cstdio/fopen.html, fopen)
function)
Throws: $(D ErrnoException) if the file could not be opened.
*/
this(string name, in char[] stdioOpenmode = "rb") @safe
{
import std.conv : text;
import std.exception : errnoEnforce;
this(errnoEnforce(.fopen(name, stdioOpenmode),
text("Cannot open file `", name, "' in mode `",
stdioOpenmode, "'")),
name);
// MSVCRT workaround (issue 14422)
version (MICROSOFT_STDIO)
{
setAppendWin(stdioOpenmode);
}
}
/// ditto
this(R1, R2)(R1 name)
if (isInputRange!R1 && isSomeChar!(ElementEncodingType!R1))
{
import std.conv : to;
this(name.to!string, "rb");
}
/// ditto
this(R1, R2)(R1 name, R2 mode)
if (isInputRange!R1 && isSomeChar!(ElementEncodingType!R1) &&
isInputRange!R2 && isSomeChar!(ElementEncodingType!R2))
{
import std.conv : to;
this(name.to!string, mode.to!string);
}
@safe unittest
{
static import std.file;
import std.utf : byChar;
auto deleteme = testFilename();
auto f = File(deleteme.byChar, "w".byChar);
f.close();
std.file.remove(deleteme);
}
~this() @safe
{
detach();
}
this(this) @safe nothrow
{
if (!_p) return;
assert(_p.refs);
++_p.refs;
}
/**
Assigns a file to another. The target of the assignment gets detached
from whatever file it was attached to, and attaches itself to the new
file.
*/
void opAssign(File rhs) @safe
{
import std.algorithm.mutation : swap;
swap(this, rhs);
}
/**
Detaches from the current file (throwing on failure), and then attempts to
_open file $(D name) with mode $(D stdioOpenmode). The mode has the
same semantics as in the C standard library $(HTTP
cplusplus.com/reference/clibrary/cstdio/fopen.html, fopen) function.
Throws: $(D ErrnoException) in case of error.
*/
void open(string name, in char[] stdioOpenmode = "rb") @trusted
{
resetFile(name, stdioOpenmode, false);
}
private void resetFile(string name, in char[] stdioOpenmode, bool isPopened) @trusted
{
import core.stdc.stdlib : malloc;
import std.exception : enforce;
import std.conv : text;
import std.exception : errnoEnforce;
if (_p is null)
{
_p = cast(Impl*) enforce(malloc(Impl.sizeof), "Out of memory");
}
else if (_p.refs == 1)
{
closeHandles();
}
else
{
_p.refs--;
_p = cast(Impl*) enforce(malloc(Impl.sizeof), "Out of memory");
}
FILE* handle;
version (Posix)
{
if (isPopened)
{
errnoEnforce(handle = .popen(name, stdioOpenmode),
"Cannot run command `"~name~"'");
}
else
{
errnoEnforce(handle = .fopen(name, stdioOpenmode),
text("Cannot open file `", name, "' in mode `",
stdioOpenmode, "'"));
}
}
else
{
assert(isPopened == false);
errnoEnforce(handle = .fopen(name, stdioOpenmode),
text("Cannot open file `", name, "' in mode `",
stdioOpenmode, "'"));
}
initImpl(handle, name, 1, isPopened);
version (MICROSOFT_STDIO)
{
setAppendWin(stdioOpenmode);
}
}
private void closeHandles() @trusted
{
assert(_p);
import std.exception : errnoEnforce;
version (Posix)
{
import core.sys.posix.stdio : pclose;
import std.format : format;
if (_p.isPopened)
{
auto res = pclose(_p.handle);
errnoEnforce(res != -1,
"Could not close pipe `"~_name~"'");
_p.handle = null;
return;
}
}
if (_p.handle)
{
errnoEnforce(.fclose(_p.handle) == 0,
"Could not close file `"~_name~"'");
_p.handle = null;
}
}
version (MICROSOFT_STDIO)
{
private void setAppendWin(in char[] stdioOpenmode) @safe
{
bool append, update;
foreach (c; stdioOpenmode)
if (c == 'a')
append = true;
else
if (c == '+')
update = true;
if (append && !update)
seek(size);
}
}
/**
Reuses the `File` object to either open a different file, or change
the file mode. If `name` is `null`, the mode of the currently open
file is changed; otherwise, a new file is opened, reusing the C
`FILE*`. The function has the same semantics as in the C standard
library $(HTTP cplusplus.com/reference/cstdio/freopen/, freopen)
function.
Note: Calling `reopen` with a `null` `name` is not implemented
in all C runtimes.
Throws: $(D ErrnoException) in case of error.
*/
void reopen(string name, in char[] stdioOpenmode = "rb") @trusted
{
import std.conv : text;
import std.exception : enforce, errnoEnforce;
import std.internal.cstring : tempCString;
enforce(isOpen, "Attempting to reopen() an unopened file");
auto namez = (name == null ? _name : name).tempCString!FSChar();
auto modez = stdioOpenmode.tempCString!FSChar();
FILE* fd = _p.handle;
version (Windows)
fd = _wfreopen(namez, modez, fd);
else
fd = freopen(namez, modez, fd);
errnoEnforce(fd, name
? text("Cannot reopen file `", name, "' in mode `", stdioOpenmode, "'")
: text("Cannot reopen file in mode `", stdioOpenmode, "'"));
if (name !is null)
_name = name;
}
@system unittest // Test changing filename
{
import std.exception : assertThrown, assertNotThrown;
static import std.file;
auto deleteme = testFilename();
std.file.write(deleteme, "foo");
scope(exit) std.file.remove(deleteme);
auto f = File(deleteme);
assert(f.readln() == "foo");
auto deleteme2 = testFilename();
std.file.write(deleteme2, "bar");
scope(exit) std.file.remove(deleteme2);
f.reopen(deleteme2);
assert(f.name == deleteme2);
assert(f.readln() == "bar");
f.close();
}
version (CRuntime_DigitalMars) {} else // Not implemented
version (CRuntime_Microsoft) {} else // Not implemented
@system unittest // Test changing mode
{
import std.exception : assertThrown, assertNotThrown;
static import std.file;
auto deleteme = testFilename();
std.file.write(deleteme, "foo");
scope(exit) std.file.remove(deleteme);
auto f = File(deleteme, "r+");
assert(f.readln() == "foo");
f.reopen(null, "w");
f.write("bar");
f.seek(0);
f.reopen(null, "a");
f.write("baz");
assert(f.name == deleteme);
f.close();
assert(std.file.readText(deleteme) == "barbaz");
}
/**
Detaches from the current file (throwing on failure), and then runs a command
by calling the C standard library function $(HTTP
opengroup.org/onlinepubs/007908799/xsh/_popen.html, _popen).
Throws: $(D ErrnoException) in case of error.
*/
version(Posix) void popen(string command, in char[] stdioOpenmode = "r") @safe
{
resetFile(command, stdioOpenmode ,true);
}
/**
First calls $(D detach) (throwing on failure), and then attempts to
associate the given file descriptor with the $(D File). The mode must
be compatible with the mode of the file descriptor.
Throws: $(D ErrnoException) in case of error.
*/
void fdopen(int fd, in char[] stdioOpenmode = "rb") @safe
{
fdopen(fd, stdioOpenmode, null);
}
package void fdopen(int fd, in char[] stdioOpenmode, string name) @trusted
{
import std.exception : errnoEnforce;
import std.internal.cstring : tempCString;
auto modez = stdioOpenmode.tempCString();
detach();
version (DIGITAL_MARS_STDIO)
{
// This is a re-implementation of DMC's fdopen, but without the
// mucking with the file descriptor. POSIX standard requires the
// new fdopen'd file to retain the given file descriptor's
// position.
import core.stdc.stdio : fopen;
auto fp = fopen("NUL", modez);
errnoEnforce(fp, "Cannot open placeholder NUL stream");
FLOCK(fp);
auto iob = cast(_iobuf*) fp;
.close(iob._file);
iob._file = fd;
iob._flag &= ~_IOTRAN;
FUNLOCK(fp);
}
else
{
version (Windows) // MSVCRT
auto fp = _fdopen(fd, modez);
else version (Posix)
{
import core.sys.posix.stdio : fdopen;
auto fp = fdopen(fd, modez);
}
errnoEnforce(fp);
}
this = File(fp, name);
}
// Declare a dummy HANDLE to allow generating documentation
// for Windows-only methods.
version(StdDdoc) { version(Windows) {} else alias HANDLE = int; }
/**
First calls $(D detach) (throwing on failure), and then attempts to
associate the given Windows $(D HANDLE) with the $(D File). The mode must
be compatible with the access attributes of the handle. Windows only.
Throws: $(D ErrnoException) in case of error.
*/
version(StdDdoc)
void windowsHandleOpen(HANDLE handle, in char[] stdioOpenmode);
version(Windows)
void windowsHandleOpen(HANDLE handle, in char[] stdioOpenmode)
{
import core.stdc.stdint : intptr_t;
import std.exception : errnoEnforce;
import std.format : format;
// Create file descriptors from the handles
version (DIGITAL_MARS_STDIO)
auto fd = _handleToFD(handle, FHND_DEVICE);
else // MSVCRT
{
int mode;
modeLoop:
foreach (c; stdioOpenmode)
switch (c)
{
case 'r': mode |= _O_RDONLY; break;
case '+': mode &=~_O_RDONLY; break;
case 'a': mode |= _O_APPEND; break;
case 'b': mode |= _O_BINARY; break;
case 't': mode |= _O_TEXT; break;
case ',': break modeLoop;
default: break;
}
auto fd = _open_osfhandle(cast(intptr_t) handle, mode);
}
errnoEnforce(fd >= 0, "Cannot open Windows HANDLE");
fdopen(fd, stdioOpenmode, "HANDLE(%s)".format(handle));
}
/** Returns $(D true) if the file is opened. */
@property bool isOpen() const @safe pure nothrow
{
return _p !is null && _p.handle;
}
/**
Returns $(D true) if the file is at end (see $(HTTP
cplusplus.com/reference/clibrary/cstdio/feof.html, feof)).
Throws: $(D Exception) if the file is not opened.
*/
@property bool eof() const @trusted pure
{
import std.exception : enforce;
enforce(_p && _p.handle, "Calling eof() against an unopened file.");
return .feof(cast(FILE*) _p.handle) != 0;
}
/** Returns the name of the last opened file, if any.
If a $(D File) was created with $(LREF tmpfile) and $(LREF wrapFile)
it has no name.*/
@property string name() const @safe pure nothrow
{
return _name;
}
/**
If the file is not opened, returns $(D true). Otherwise, returns
$(HTTP cplusplus.com/reference/clibrary/cstdio/ferror.html, ferror) for
the file handle.
*/
@property bool error() const @trusted pure nothrow
{
return !isOpen || .ferror(cast(FILE*) _p.handle);
}
@safe unittest
{
// Issue 12349
static import std.file;
auto deleteme = testFilename();
auto f = File(deleteme, "w");
scope(exit) std.file.remove(deleteme);
f.close();
assert(f.error);
}
/**
Detaches from the underlying file. If the sole owner, calls $(D close).
Throws: $(D ErrnoException) on failure if closing the file.
*/
void detach() @safe
{
if (!_p) return;
if (_p.refs == 1)
close();
else
{
assert(_p.refs);
--_p.refs;
_p = null;
}
}
@safe unittest
{
static import std.file;
auto deleteme = testFilename();
scope(exit) std.file.remove(deleteme);
auto f = File(deleteme, "w");
{
auto f2 = f;
f2.detach();
}
assert(f._p.refs == 1);
f.close();
}
/**
If the file was unopened, succeeds vacuously. Otherwise closes the
file (by calling $(HTTP
cplusplus.com/reference/clibrary/cstdio/fclose.html, fclose)),
throwing on error. Even if an exception is thrown, afterwards the $(D
File) object is empty. This is different from $(D detach) in that it
always closes the file; consequently, all other $(D File) objects
referring to the same handle will see a closed file henceforth.
Throws: $(D ErrnoException) on error.
*/
void close() @trusted
{
import core.stdc.stdlib : free;
import std.exception : errnoEnforce;
if (!_p) return; // succeed vacuously
scope(exit)
{
assert(_p.refs);
if (!--_p.refs)
free(_p);
_p = null; // start a new life
}
if (!_p.handle) return; // Impl is closed by another File
scope(exit) _p.handle = null; // nullify the handle anyway
closeHandles();
}
/**
If the file is not opened, succeeds vacuously. Otherwise, returns
$(HTTP cplusplus.com/reference/clibrary/cstdio/_clearerr.html,
_clearerr) for the file handle.
*/
void clearerr() @safe pure nothrow
{
_p is null || _p.handle is null ||
.clearerr(_p.handle);
}
/**
Flushes the C $(D FILE) buffers.
Calls $(HTTP cplusplus.com/reference/clibrary/cstdio/_fflush.html, _fflush)
for the file handle.
Throws: $(D Exception) if the file is not opened or if the call to $(D fflush) fails.
*/
void flush() @trusted
{
import std.exception : enforce, errnoEnforce;
enforce(isOpen, "Attempting to flush() in an unopened file");
errnoEnforce(.fflush(_p.handle) == 0);
}
@safe unittest
{
// Issue 12349
import std.exception : assertThrown;
static import std.file;
auto deleteme = testFilename();
auto f = File(deleteme, "w");
scope(exit) std.file.remove(deleteme);
f.close();
assertThrown(f.flush());
}
/**
Forces any data buffered by the OS to be written to disk.
Call $(LREF flush) before calling this function to flush the C $(D FILE) buffers first.
This function calls
$(HTTP msdn.microsoft.com/en-us/library/windows/desktop/aa364439%28v=vs.85%29.aspx,
$(D FlushFileBuffers)) on Windows and
$(HTTP pubs.opengroup.org/onlinepubs/7908799/xsh/fsync.html,
$(D fsync)) on POSIX for the file handle.
Throws: $(D Exception) if the file is not opened or if the OS call fails.
*/
void sync() @trusted
{
import std.exception : enforce;
enforce(isOpen, "Attempting to sync() an unopened file");
version (Windows)
{
import core.sys.windows.windows : FlushFileBuffers;
wenforce(FlushFileBuffers(windowsHandle), "FlushFileBuffers failed");
}
else
{
import core.sys.posix.unistd : fsync;
import std.exception : errnoEnforce;
errnoEnforce(fsync(fileno) == 0, "fsync failed");
}
}
/**
Calls $(HTTP cplusplus.com/reference/clibrary/cstdio/fread.html, fread) for the
file handle. The number of items to read and the size of
each item is inferred from the size and type of the input array, respectively.
Returns: The slice of $(D buffer) containing the data that was actually read.
This will be shorter than $(D buffer) if EOF was reached before the buffer
could be filled.
Throws: $(D Exception) if $(D buffer) is empty.
$(D ErrnoException) if the file is not opened or the call to $(D fread) fails.
$(D rawRead) always reads in binary mode on Windows.
*/
T[] rawRead(T)(T[] buffer)
{
import std.exception : errnoEnforce;
if (!buffer.length)
throw new Exception("rawRead must take a non-empty buffer");
version(Windows)
{
immutable fd = ._fileno(_p.handle);
immutable mode = ._setmode(fd, _O_BINARY);
scope(exit) ._setmode(fd, mode);
version(DIGITAL_MARS_STDIO)
{
import core.atomic : atomicOp;
// @@@BUG@@@ 4243
immutable info = __fhnd_info[fd];
atomicOp!"&="(__fhnd_info[fd], ~FHND_TEXT);
scope(exit) __fhnd_info[fd] = info;
}
}
immutable freadResult = trustedFread(_p.handle, buffer);
assert(freadResult <= buffer.length); // fread return guarantee
if (freadResult != buffer.length) // error or eof
{
errnoEnforce(!error);
return buffer[0 .. freadResult];
}
return buffer;
}
///
@system unittest
{
static import std.file;
auto testFile = std.file.deleteme();
std.file.write(testFile, "\r\n\n\r\n");
scope(exit) std.file.remove(testFile);
auto f = File(testFile, "r");
auto buf = f.rawRead(new char[5]);
f.close();
assert(buf == "\r\n\n\r\n");
}
/**
Calls $(HTTP cplusplus.com/reference/clibrary/cstdio/fwrite.html, fwrite) for the file
handle. The number of items to write and the size of each
item is inferred from the size and type of the input array, respectively. An
error is thrown if the buffer could not be written in its entirety.
$(D rawWrite) always writes in binary mode on Windows.
Throws: $(D ErrnoException) if the file is not opened or if the call to $(D fwrite) fails.
*/
void rawWrite(T)(in T[] buffer)
{
import std.conv : text;
import std.exception : errnoEnforce;
version(Windows)
{
flush(); // before changing translation mode
immutable fd = ._fileno(_p.handle);
immutable mode = ._setmode(fd, _O_BINARY);
scope(exit) ._setmode(fd, mode);
version(DIGITAL_MARS_STDIO)
{
import core.atomic : atomicOp;
// @@@BUG@@@ 4243
immutable info = __fhnd_info[fd];
atomicOp!"&="(__fhnd_info[fd], ~FHND_TEXT);
scope(exit) __fhnd_info[fd] = info;
}
scope(exit) flush(); // before restoring translation mode
}
auto result = trustedFwrite(_p.handle, buffer);
if (result == result.max) result = 0;
errnoEnforce(result == buffer.length,
text("Wrote ", result, " instead of ", buffer.length,
" objects of type ", T.stringof, " to file `",
_name, "'"));
}
///
@system unittest
{
static import std.file;
auto testFile = std.file.deleteme();
auto f = File(testFile, "w");
scope(exit) std.file.remove(testFile);
f.rawWrite("\r\n\n\r\n");
f.close();
assert(std.file.read(testFile) == "\r\n\n\r\n");
}
/**
Calls $(HTTP cplusplus.com/reference/clibrary/cstdio/fseek.html, fseek)
for the file handle.
Throws: $(D Exception) if the file is not opened.
$(D ErrnoException) if the call to $(D fseek) fails.
*/
void seek(long offset, int origin = SEEK_SET) @trusted
{
import std.conv : to, text;
import std.exception : enforce, errnoEnforce;
enforce(isOpen, "Attempting to seek() in an unopened file");
version (Windows)
{
version (CRuntime_Microsoft)
{
alias fseekFun = _fseeki64;
alias off_t = long;
}
else
{
alias fseekFun = fseek;
alias off_t = int;
}
}
else version (Posix)
{
import core.sys.posix.stdio : fseeko, off_t;
alias fseekFun = fseeko;
}
errnoEnforce(fseekFun(_p.handle, to!off_t(offset), origin) == 0,
"Could not seek in file `"~_name~"'");
}
@system unittest
{
import std.conv : text;
static import std.file;
auto deleteme = testFilename();
auto f = File(deleteme, "w+");
scope(exit) { f.close(); std.file.remove(deleteme); }
f.rawWrite("abcdefghijklmnopqrstuvwxyz");
f.seek(7);
assert(f.readln() == "hijklmnopqrstuvwxyz");
version (CRuntime_DigitalMars)
auto bigOffset = int.max - 100;
else
version (CRuntime_Bionic)
auto bigOffset = int.max - 100;
else
auto bigOffset = cast(ulong) int.max + 100;
f.seek(bigOffset);
assert(f.tell == bigOffset, text(f.tell));
// Uncomment the tests below only if you want to wait for
// a long time
// f.rawWrite("abcdefghijklmnopqrstuvwxyz");
// f.seek(-3, SEEK_END);
// assert(f.readln() == "xyz");
}
/**
Calls $(HTTP cplusplus.com/reference/clibrary/cstdio/ftell.html, ftell) for the
managed file handle.
Throws: $(D Exception) if the file is not opened.
$(D ErrnoException) if the call to $(D ftell) fails.
*/
@property ulong tell() const @trusted
{
import std.exception : enforce, errnoEnforce;
enforce(isOpen, "Attempting to tell() in an unopened file");
version (Windows)
{
version (CRuntime_Microsoft)
immutable result = _ftelli64(cast(FILE*) _p.handle);
else
immutable result = ftell(cast(FILE*) _p.handle);
}
else version (Posix)
{
import core.sys.posix.stdio : ftello;
immutable result = ftello(cast(FILE*) _p.handle);
}
errnoEnforce(result != -1,
"Query ftell() failed for file `"~_name~"'");
return result;
}
///
@system unittest
{
import std.conv : text;
static import std.file;
auto testFile = std.file.deleteme();
std.file.write(testFile, "abcdefghijklmnopqrstuvwqxyz");
scope(exit) { std.file.remove(testFile); }
auto f = File(testFile);
auto a = new ubyte[4];
f.rawRead(a);
assert(f.tell == 4, text(f.tell));
}
/**
Calls $(HTTP cplusplus.com/reference/clibrary/cstdio/_rewind.html, _rewind)
for the file handle.
Throws: $(D Exception) if the file is not opened.
*/
void rewind() @safe
{
import std.exception : enforce;
enforce(isOpen, "Attempting to rewind() an unopened file");
.rewind(_p.handle);
}
/**
Calls $(HTTP cplusplus.com/reference/clibrary/cstdio/_setvbuf.html, _setvbuf) for
the file handle.
Throws: $(D Exception) if the file is not opened.
$(D ErrnoException) if the call to $(D setvbuf) fails.
*/
void setvbuf(size_t size, int mode = _IOFBF) @trusted
{
import std.exception : enforce, errnoEnforce;
enforce(isOpen, "Attempting to call setvbuf() on an unopened file");
errnoEnforce(.setvbuf(_p.handle, null, mode, size) == 0,
"Could not set buffering for file `"~_name~"'");
}
/**
Calls $(HTTP cplusplus.com/reference/clibrary/cstdio/_setvbuf.html,
_setvbuf) for the file handle.
Throws: $(D Exception) if the file is not opened.
$(D ErrnoException) if the call to $(D setvbuf) fails.
*/
void setvbuf(void[] buf, int mode = _IOFBF) @trusted
{
import std.exception : enforce, errnoEnforce;
enforce(isOpen, "Attempting to call setvbuf() on an unopened file");
errnoEnforce(.setvbuf(_p.handle,
cast(char*) buf.ptr, mode, buf.length) == 0,
"Could not set buffering for file `"~_name~"'");
}
version(Windows)
{
import core.sys.windows.windows : ULARGE_INTEGER, OVERLAPPED, BOOL;
private BOOL lockImpl(alias F, Flags...)(ulong start, ulong length,
Flags flags)
{
if (!start && !length)
length = ulong.max;
ULARGE_INTEGER liStart = void, liLength = void;
liStart.QuadPart = start;
liLength.QuadPart = length;
OVERLAPPED overlapped;
overlapped.Offset = liStart.LowPart;
overlapped.OffsetHigh = liStart.HighPart;
overlapped.hEvent = null;
return F(windowsHandle, flags, 0, liLength.LowPart,
liLength.HighPart, &overlapped);
}
private static T wenforce(T)(T cond, string str)
{
import core.sys.windows.windows : GetLastError;
import std.windows.syserror : sysErrorString;
if (cond) return cond;
throw new Exception(str ~ ": " ~ sysErrorString(GetLastError()));
}
}
version(Posix)
{
private int lockImpl(int operation, short l_type,
ulong start, ulong length)
{
import core.sys.posix.fcntl : fcntl, flock, off_t;
import core.sys.posix.unistd : getpid;
import std.conv : to;
flock fl = void;
fl.l_type = l_type;
fl.l_whence = SEEK_SET;
fl.l_start = to!off_t(start);
fl.l_len = to!off_t(length);
fl.l_pid = getpid();
return fcntl(fileno, operation, &fl);
}
}
/**
Locks the specified file segment. If the file segment is already locked
by another process, waits until the existing lock is released.
If both $(D start) and $(D length) are zero, the entire file is locked.
Locks created using $(D lock) and $(D tryLock) have the following properties:
$(UL
$(LI All locks are automatically released when the process terminates.)
$(LI Locks are not inherited by child processes.)
$(LI Closing a file will release all locks associated with the file. On POSIX,
even locks acquired via a different $(D File) will be released as well.)
$(LI Not all NFS implementations correctly implement file locking.)
)
*/
void lock(LockType lockType = LockType.readWrite,
ulong start = 0, ulong length = 0)
{
import std.exception : enforce;
enforce(isOpen, "Attempting to call lock() on an unopened file");
version (Posix)
{
import core.sys.posix.fcntl : F_RDLCK, F_SETLKW, F_WRLCK;
import std.exception : errnoEnforce;
immutable short type = lockType == LockType.readWrite
? F_WRLCK : F_RDLCK;
errnoEnforce(lockImpl(F_SETLKW, type, start, length) != -1,
"Could not set lock for file `"~_name~"'");
}
else
version(Windows)
{
import core.sys.windows.windows : LockFileEx, LOCKFILE_EXCLUSIVE_LOCK;
immutable type = lockType == LockType.readWrite ?
LOCKFILE_EXCLUSIVE_LOCK : 0;
wenforce(lockImpl!LockFileEx(start, length, type),
"Could not set lock for file `"~_name~"'");
}
else
static assert(false);
}
/**
Attempts to lock the specified file segment.
If both $(D start) and $(D length) are zero, the entire file is locked.
Returns: $(D true) if the lock was successful, and $(D false) if the
specified file segment was already locked.
*/
bool tryLock(LockType lockType = LockType.readWrite,
ulong start = 0, ulong length = 0)
{
import std.exception : enforce;
enforce(isOpen, "Attempting to call tryLock() on an unopened file");
version (Posix)
{
import core.stdc.errno : EACCES, EAGAIN, errno;
import core.sys.posix.fcntl : F_RDLCK, F_SETLK, F_WRLCK;
import std.exception : errnoEnforce;
immutable short type = lockType == LockType.readWrite
? F_WRLCK : F_RDLCK;
immutable res = lockImpl(F_SETLK, type, start, length);
if (res == -1 && (errno == EACCES || errno == EAGAIN))
return false;
errnoEnforce(res != -1, "Could not set lock for file `"~_name~"'");
return true;
}
else
version(Windows)
{
import core.sys.windows.windows : GetLastError, LockFileEx, LOCKFILE_EXCLUSIVE_LOCK,
ERROR_IO_PENDING, ERROR_LOCK_VIOLATION, LOCKFILE_FAIL_IMMEDIATELY;
immutable type = lockType == LockType.readWrite
? LOCKFILE_EXCLUSIVE_LOCK : 0;
immutable res = lockImpl!LockFileEx(start, length,
type | LOCKFILE_FAIL_IMMEDIATELY);
if (!res && (GetLastError() == ERROR_IO_PENDING
|| GetLastError() == ERROR_LOCK_VIOLATION))
return false;
wenforce(res, "Could not set lock for file `"~_name~"'");
return true;
}
else
static assert(false);
}
/**
Removes the lock over the specified file segment.
*/
void unlock(ulong start = 0, ulong length = 0)
{
import std.exception : enforce;
enforce(isOpen, "Attempting to call unlock() on an unopened file");
version (Posix)
{
import core.sys.posix.fcntl : F_SETLK, F_UNLCK;
import std.exception : errnoEnforce;
errnoEnforce(lockImpl(F_SETLK, F_UNLCK, start, length) != -1,
"Could not remove lock for file `"~_name~"'");
}
else
version(Windows)
{
import core.sys.windows.windows : UnlockFileEx;
wenforce(lockImpl!UnlockFileEx(start, length),
"Could not remove lock for file `"~_name~"'");
}
else
static assert(false);
}
version(Windows)
@system unittest
{
static import std.file;
auto deleteme = testFilename();
scope(exit) std.file.remove(deleteme);
auto f = File(deleteme, "wb");
assert(f.tryLock());
auto g = File(deleteme, "wb");
assert(!g.tryLock());
assert(!g.tryLock(LockType.read));
f.unlock();
f.lock(LockType.read);
assert(!g.tryLock());
assert(g.tryLock(LockType.read));
f.unlock();
g.unlock();
}
version(Posix)
@system unittest
{
static import std.file;
auto deleteme = testFilename();
scope(exit) std.file.remove(deleteme);
// Since locks are per-process, we cannot test lock failures within
// the same process. fork() is used to create a second process.
static void runForked(void delegate() code)
{
import core.stdc.stdlib : exit;
import core.sys.posix.sys.wait : wait;
import core.sys.posix.unistd : fork;
int child, status;
if ((child = fork()) == 0)
{
code();
exit(0);
}
else
{
assert(wait(&status) != -1);
assert(status == 0, "Fork crashed");
}
}
auto f = File(deleteme, "w+b");
runForked
({
auto g = File(deleteme, "a+b");
assert(g.tryLock());
g.unlock();
assert(g.tryLock(LockType.read));
});
assert(f.tryLock());
runForked
({
auto g = File(deleteme, "a+b");
assert(!g.tryLock());
assert(!g.tryLock(LockType.read));
});
f.unlock();
f.lock(LockType.read);
runForked
({
auto g = File(deleteme, "a+b");
assert(!g.tryLock());
assert(g.tryLock(LockType.read));
g.unlock();
});
f.unlock();
}
/**
Writes its arguments in text format to the file.
Throws: $(D Exception) if the file is not opened.
$(D ErrnoException) on an error writing to the file.
*/
void write(S...)(S args)
{
import std.traits : isBoolean, isIntegral, isAggregateType;
auto w = lockingTextWriter();
foreach (arg; args)
{
alias A = typeof(arg);
static if (isAggregateType!A || is(A == enum))
{
import std.format : formattedWrite;
formattedWrite(w, "%s", arg);
}
else static if (isSomeString!A)
{
put(w, arg);
}
else static if (isIntegral!A)
{
import std.conv : toTextRange;
toTextRange(arg, w);
}
else static if (isBoolean!A)
{
put(w, arg ? "true" : "false");
}
else static if (isSomeChar!A)
{
put(w, arg);
}
else
{
import std.format : formattedWrite;
// Most general case
formattedWrite(w, "%s", arg);
}
}
}
/**
Writes its arguments in text format to the file, followed by a newline.
Throws: $(D Exception) if the file is not opened.
$(D ErrnoException) on an error writing to the file.
*/
void writeln(S...)(S args)
{
write(args, '\n');
}
/**
Writes its arguments in text format to the file, according to the
format string fmt.
Params:
fmt = The $(REF_ALTTEXT format string, formattedWrite, std, _format).
When passed as a compile-time argument, the string will be statically checked
against the argument types passed.
args = Items to write.
Throws: $(D Exception) if the file is not opened.
$(D ErrnoException) on an error writing to the file.
*/
void writef(alias fmt, A...)(A args)
if (isSomeString!(typeof(fmt)))
{
import std.format : checkFormatException;
alias e = checkFormatException!(fmt, A);
static assert(!e, e.msg);
return this.writef(fmt, args);
}
/// ditto
void writef(Char, A...)(in Char[] fmt, A args)
{
import std.format : formattedWrite;
formattedWrite(lockingTextWriter(), fmt, args);
}
/// Equivalent to `file.writef(fmt, args, '\n')`.
void writefln(alias fmt, A...)(A args)
if (isSomeString!(typeof(fmt)))
{
import std.format : checkFormatException;
alias e = checkFormatException!(fmt, A);
static assert(!e, e.msg);
return this.writefln(fmt, args);
}
/// ditto
void writefln(Char, A...)(in Char[] fmt, A args)
{
import std.format : formattedWrite;
auto w = lockingTextWriter();
formattedWrite(w, fmt, args);
w.put('\n');
}
/**
Read line from the file handle and return it as a specified type.
This version manages its own read buffer, which means one memory allocation per call. If you are not
retaining a reference to the read data, consider the $(D File.readln(buf)) version, which may offer
better performance as it can reuse its read buffer.
Params:
S = Template parameter; the type of the allocated buffer, and the type returned. Defaults to $(D string).
terminator = Line terminator (by default, $(D '\n')).
Note:
String terminators are not supported due to ambiguity with readln(buf) below.
Returns:
The line that was read, including the line terminator character.
Throws:
$(D StdioException) on I/O error, or $(D UnicodeException) on Unicode conversion error.
Example:
---
// Reads `stdin` and writes it to `stdout`.
import std.stdio;
void main()
{
string line;
while ((line = stdin.readln()) !is null)
write(line);
}
---
*/
S readln(S = string)(dchar terminator = '\n')
if (isSomeString!S)
{
Unqual!(ElementEncodingType!S)[] buf;
readln(buf, terminator);
return cast(S) buf;
}
@system unittest
{
import std.algorithm.comparison : equal;
static import std.file;
import std.meta : AliasSeq;
auto deleteme = testFilename();
std.file.write(deleteme, "hello\nworld\n");
scope(exit) std.file.remove(deleteme);
static foreach (String; AliasSeq!(string, char[], wstring, wchar[], dstring, dchar[]))
{{
auto witness = [ "hello\n", "world\n" ];
auto f = File(deleteme);
uint i = 0;
String buf;
while ((buf = f.readln!String()).length)
{
assert(i < witness.length);
assert(equal(buf, witness[i++]));
}
assert(i == witness.length);
}}
}
@system unittest
{
static import std.file;
import std.typecons : Tuple;
auto deleteme = testFilename();
std.file.write(deleteme, "cześć \U0002000D");
scope(exit) std.file.remove(deleteme);
uint[] lengths = [12,8,7];
static foreach (uint i, C; Tuple!(char, wchar, dchar).Types)
{{
immutable(C)[] witness = "cześć \U0002000D";
auto buf = File(deleteme).readln!(immutable(C)[])();
assert(buf.length == lengths[i]);
assert(buf == witness);
}}
}
/**
Read line from the file handle and write it to $(D buf[]), including
terminating character.
This can be faster than $(D line = File.readln()) because you can reuse
the buffer for each call. Note that reusing the buffer means that you
must copy the previous contents if you wish to retain them.
Params:
buf = Buffer used to store the resulting line data. buf is
resized as necessary.
terminator = Line terminator (by default, $(D '\n')). Use
$(REF newline, std,ascii) for portability (unless the file was opened in
text mode).
Returns:
0 for end of file, otherwise number of characters read
Throws: $(D StdioException) on I/O error, or $(D UnicodeException) on Unicode
conversion error.
Example:
---
// Read lines from `stdin` into a string
// Ignore lines starting with '#'
// Write the string to `stdout`
void main()
{
string output;
char[] buf;
while (stdin.readln(buf))
{
if (buf[0] == '#')
continue;
output ~= buf;
}
write(output);
}
---
This method can be more efficient than the one in the previous example
because $(D stdin.readln(buf)) reuses (if possible) memory allocated
for $(D buf), whereas $(D line = stdin.readln()) makes a new memory allocation
for every line.
For even better performance you can help $(D readln) by passing in a
large buffer to avoid memory reallocations. This can be done by reusing the
largest buffer returned by $(D readln):
Example:
---
// Read lines from `stdin` and count words
void main()
{
char[] buf;
size_t words = 0;
while (!stdin.eof)
{
char[] line = buf;
stdin.readln(line);
if (line.length > buf.length)
buf = line;
words += line.split.length;
}
writeln(words);
}
---
This is actually what $(LREF byLine) does internally, so its usage
is recommended if you want to process a complete file.
*/
size_t readln(C)(ref C[] buf, dchar terminator = '\n')
if (isSomeChar!C && is(Unqual!C == C) && !is(C == enum))
{
import std.exception : enforce;
static if (is(C == char))
{
enforce(_p && _p.handle, "Attempt to read from an unopened file.");
if (_p.orientation == Orientation.unknown)
{
import core.stdc.wchar_ : fwide;
auto w = fwide(_p.handle, 0);
if (w < 0) _p.orientation = Orientation.narrow;
else if (w > 0) _p.orientation = Orientation.wide;
}
return readlnImpl(_p.handle, buf, terminator, _p.orientation);
}
else
{
// TODO: optimize this
string s = readln(terminator);
buf.length = 0;
if (!s.length) return 0;
foreach (C c; s)
{
buf ~= c;
}
return buf.length;
}
}
@system unittest
{
// @system due to readln
static import std.file;
auto deleteme = testFilename();
std.file.write(deleteme, "123\n456789");
scope(exit) std.file.remove(deleteme);
auto file = File(deleteme);
char[] buffer = new char[10];
char[] line = buffer;
file.readln(line);
auto beyond = line.length;
buffer[beyond] = 'a';
file.readln(line); // should not write buffer beyond line
assert(buffer[beyond] == 'a');
}
@system unittest // bugzilla 15293
{
// @system due to readln
static import std.file;
auto deleteme = testFilename();
std.file.write(deleteme, "a\n\naa");
scope(exit) std.file.remove(deleteme);
auto file = File(deleteme);
char[] buffer;
char[] line;
file.readln(buffer, '\n');
line = buffer;
file.readln(line, '\n');
line = buffer;
file.readln(line, '\n');
assert(line[0 .. 1].capacity == 0);
}
/** ditto */
size_t readln(C, R)(ref C[] buf, R terminator)
if (isSomeChar!C && is(Unqual!C == C) && !is(C == enum) &&
isBidirectionalRange!R && is(typeof(terminator.front == dchar.init)))
{
import std.algorithm.mutation : swap;
import std.algorithm.searching : endsWith;
import std.range.primitives : back;
auto last = terminator.back;
C[] buf2;
swap(buf, buf2);
for (;;)
{
if (!readln(buf2, last) || endsWith(buf2, terminator))
{
if (buf.empty)
{
buf = buf2;
}
else
{
buf ~= buf2;
}
break;
}
buf ~= buf2;
}
return buf.length;
}
@system unittest
{
static import std.file;
import std.typecons : Tuple;
auto deleteme = testFilename();
std.file.write(deleteme, "hello\n\rworld\nhow\n\rare ya");
scope(exit) std.file.remove(deleteme);
foreach (C; Tuple!(char, wchar, dchar).Types)
{
immutable(C)[][] witness = [ "hello\n\r", "world\nhow\n\r", "are ya" ];
auto f = File(deleteme);
uint i = 0;
C[] buf;
while (f.readln(buf, "\n\r"))
{
assert(i < witness.length);
assert(buf == witness[i++]);
}
assert(buf.length == 0);
}
}
/**
* Reads formatted _data from the file using $(REF formattedRead, std,_format).
* Params:
* format = The $(REF_ALTTEXT format string, formattedWrite, std _format).
* When passed as a compile-time argument, the string will be statically checked
* against the argument types passed.
* data = Items to be read.
* Example:
----
// test.d
void main()
{
import std.stdio;
auto f = File("input");
foreach (_; 0 .. 3)
{
int a;
f.readf!" %d"(a);
writeln(++a);
}
}
----
$(CONSOLE
% echo "1 2 3" > input
% rdmd test.d
2
3
4
)
*/
uint readf(alias format, Data...)(auto ref Data data)
if (isSomeString!(typeof(format)))
{
import std.format : checkFormatException;
alias e = checkFormatException!(format, Data);
static assert(!e, e.msg);
return this.readf(format, data);
}
/// ditto
uint readf(Data...)(in char[] format, auto ref Data data)
{
import std.format : formattedRead;
assert(isOpen);
auto input = LockingTextReader(this);
return formattedRead(input, format, data);
}
///
@system unittest
{
static import std.file;
auto deleteme = std.file.deleteme();
std.file.write(deleteme, "hello\nworld\ntrue\nfalse\n");
scope(exit) std.file.remove(deleteme);
string s;
auto f = File(deleteme);
f.readf!"%s\n"(s);
assert(s == "hello", "["~s~"]");
f.readf("%s\n", s);
assert(s == "world", "["~s~"]");
bool b1, b2;
f.readf("%s\n%s\n", b1, b2);
assert(b1 == true && b2 == false);
}
// backwards compatibility with pointers
@system unittest
{
// @system due to readf
static import std.file;
auto deleteme = testFilename();
std.file.write(deleteme, "hello\nworld\ntrue\nfalse\n");
scope(exit) std.file.remove(deleteme);
string s;
auto f = File(deleteme);
f.readf("%s\n", &s);
assert(s == "hello", "["~s~"]");
f.readf("%s\n", &s);
assert(s == "world", "["~s~"]");
// Issue 11698
bool b1, b2;
f.readf("%s\n%s\n", &b1, &b2);
assert(b1 == true && b2 == false);
}
// backwards compatibility (mixed)
@system unittest
{
// @system due to readf
static import std.file;
auto deleteme = testFilename();
std.file.write(deleteme, "hello\nworld\ntrue\nfalse\n");
scope(exit) std.file.remove(deleteme);
string s1, s2;
auto f = File(deleteme);
f.readf("%s\n%s\n", s1, &s2);
assert(s1 == "hello");
assert(s2 == "world");
// Issue 11698
bool b1, b2;
f.readf("%s\n%s\n", &b1, b2);
assert(b1 == true && b2 == false);
}
// Issue 12260 - Nice error of std.stdio.readf with newlines
@system unittest
{
static import std.file;
auto deleteme = testFilename();
std.file.write(deleteme, "1\n2");
scope(exit) std.file.remove(deleteme);
int input;
auto f = File(deleteme);
f.readf("%s", &input);
import std.conv : ConvException;
import std.exception : collectException;
assert(collectException!ConvException(f.readf("%s", &input)).msg ==
"Unexpected '\\n' when converting from type LockingTextReader to type int");
}
/**
Returns a temporary file by calling
$(HTTP cplusplus.com/reference/clibrary/cstdio/_tmpfile.html, _tmpfile).
Note that the created file has no $(LREF name).*/
static File tmpfile() @safe
{
import std.exception : errnoEnforce;
return File(errnoEnforce(.tmpfile(),
"Could not create temporary file with tmpfile()"),
null);
}
/**
Unsafe function that wraps an existing $(D FILE*). The resulting $(D
File) never takes the initiative in closing the file.
Note that the created file has no $(LREF name)*/
/*private*/ static File wrapFile(FILE* f) @safe
{
import std.exception : enforce;
return File(enforce(f, "Could not wrap null FILE*"),
null, /*uint.max / 2*/ 9999);
}
/**
Returns the $(D FILE*) corresponding to this object.
*/
FILE* getFP() @safe pure
{
import std.exception : enforce;
enforce(_p && _p.handle,
"Attempting to call getFP() on an unopened file");
return _p.handle;
}
@system unittest
{
static import core.stdc.stdio;
assert(stdout.getFP() == core.stdc.stdio.stdout);
}
/**
Returns the file number corresponding to this object.
*/
@property int fileno() const @trusted
{
import std.exception : enforce;
enforce(isOpen, "Attempting to call fileno() on an unopened file");
return .fileno(cast(FILE*) _p.handle);
}
/**
Returns the underlying operating system $(D HANDLE) (Windows only).
*/
version(StdDdoc)
@property HANDLE windowsHandle();
version(Windows)
@property HANDLE windowsHandle()
{
version (DIGITAL_MARS_STDIO)
return _fdToHandle(fileno);
else
return cast(HANDLE)_get_osfhandle(fileno);
}
// Note: This was documented until 2013/08
/*
Range that reads one line at a time. Returned by $(LREF byLine).
Allows to directly use range operations on lines of a file.
*/
private struct ByLineImpl(Char, Terminator)
{
private:
import std.typecons : RefCounted, RefCountedAutoInitialize;
/* Ref-counting stops the source range's Impl
* from getting out of sync after the range is copied, e.g.
* when accessing range.front, then using std.range.take,
* then accessing range.front again. */
alias PImpl = RefCounted!(Impl, RefCountedAutoInitialize.no);
PImpl impl;
static if (isScalarType!Terminator)
enum defTerm = '\n';
else
enum defTerm = cast(Terminator)"\n";
public:
this(File f, KeepTerminator kt = No.keepTerminator,
Terminator terminator = defTerm)
{
impl = PImpl(f, kt, terminator);
}
@property bool empty()
{
return impl.refCountedPayload.empty;
}
@property Char[] front()
{
return impl.refCountedPayload.front;
}
void popFront()
{
impl.refCountedPayload.popFront();
}
private:
struct Impl
{
private:
File file;
Char[] line;
Char[] buffer;
Terminator terminator;
KeepTerminator keepTerminator;
public:
this(File f, KeepTerminator kt, Terminator terminator)
{
file = f;
this.terminator = terminator;
keepTerminator = kt;
popFront();
}
// Range primitive implementations.
@property bool empty()
{
return line is null;
}
@property Char[] front()
{
return line;
}
void popFront()
{
import std.algorithm.searching : endsWith;
assert(file.isOpen);
line = buffer;
file.readln(line, terminator);
if (line.length > buffer.length)
{
buffer = line;
}
if (line.empty)
{
file.detach();
line = null;
}
else if (keepTerminator == No.keepTerminator
&& endsWith(line, terminator))
{
static if (isScalarType!Terminator)
enum tlen = 1;
else static if (isArray!Terminator)
{
static assert(
is(Unqual!(ElementEncodingType!Terminator) == Char));
const tlen = terminator.length;
}
else
static assert(false);
line = line[0 .. line.length - tlen];
}
}
}
}
// @@@DEPRECATED_2019-01@@@
deprecated("Use .byLine")
struct ByLine(Char, Terminator)
{
ByLineImpl!(Char, Terminator) payload;
alias payload this;
}
/**
Returns an input range set up to read from the file handle one line
at a time.
The element type for the range will be $(D Char[]). Range primitives
may throw $(D StdioException) on I/O error.
Note:
Each $(D front) will not persist after $(D
popFront) is called, so the caller must copy its contents (e.g. by
calling $(D to!string)) when retention is needed. If the caller needs
to retain a copy of every line, use the $(LREF byLineCopy) function
instead.
Params:
Char = Character type for each line, defaulting to $(D char).
keepTerminator = Use $(D Yes.keepTerminator) to include the
terminator at the end of each line.
terminator = Line separator ($(D '\n') by default). Use
$(REF newline, std,ascii) for portability (unless the file was opened in
text mode).
Example:
----
import std.algorithm, std.stdio, std.string;
// Count words in a file using ranges.
void main()
{
auto file = File("file.txt"); // Open for reading
const wordCount = file.byLine() // Read lines
.map!split // Split into words
.map!(a => a.length) // Count words per line
.sum(); // Total word count
writeln(wordCount);
}
----
Example:
----
import std.range, std.stdio;
// Read lines using foreach.
void main()
{
auto file = File("file.txt"); // Open for reading
auto range = file.byLine();
// Print first three lines
foreach (line; range.take(3))
writeln(line);
// Print remaining lines beginning with '#'
foreach (line; range)
{
if (!line.empty && line[0] == '#')
writeln(line);
}
}
----
Notice that neither example accesses the line data returned by
$(D front) after the corresponding $(D popFront) call is made (because
the contents may well have changed).
*/
auto byLine(Terminator = char, Char = char)
(KeepTerminator keepTerminator = No.keepTerminator,
Terminator terminator = '\n')
if (isScalarType!Terminator)
{
return ByLineImpl!(Char, Terminator)(this, keepTerminator, terminator);
}
/// ditto
auto byLine(Terminator, Char = char)
(KeepTerminator keepTerminator, Terminator terminator)
if (is(Unqual!(ElementEncodingType!Terminator) == Char))
{
return ByLineImpl!(Char, Terminator)(this, keepTerminator, terminator);
}
@system unittest
{
static import std.file;
auto deleteme = testFilename();
std.file.write(deleteme, "hi");
scope(success) std.file.remove(deleteme);
import std.meta : AliasSeq;
static foreach (T; AliasSeq!(char, wchar, dchar))
{{
auto blc = File(deleteme).byLine!(T, T);
assert(blc.front == "hi");
// check front is cached
assert(blc.front is blc.front);
}}
}
private struct ByLineCopy(Char, Terminator)
{
private:
import std.typecons : RefCounted, RefCountedAutoInitialize;
/* Ref-counting stops the source range's ByLineCopyImpl
* from getting out of sync after the range is copied, e.g.
* when accessing range.front, then using std.range.take,
* then accessing range.front again. */
alias Impl = RefCounted!(ByLineCopyImpl!(Char, Terminator),
RefCountedAutoInitialize.no);
Impl impl;
public:
this(File f, KeepTerminator kt, Terminator terminator)
{
impl = Impl(f, kt, terminator);
}
@property bool empty()
{
return impl.refCountedPayload.empty;
}
@property Char[] front()
{
return impl.refCountedPayload.front;
}
void popFront()
{
impl.refCountedPayload.popFront();
}
}
private struct ByLineCopyImpl(Char, Terminator)
{
ByLineImpl!(Unqual!Char, Terminator).Impl impl;
bool gotFront;
Char[] line;
public:
this(File f, KeepTerminator kt, Terminator terminator)
{
impl = ByLineImpl!(Unqual!Char, Terminator).Impl(f, kt, terminator);
}
@property bool empty()
{
return impl.empty;
}
@property front()
{
if (!gotFront)
{
line = impl.front.dup;
gotFront = true;
}
return line;
}
void popFront()
{
impl.popFront();
gotFront = false;
}
}
/**
Returns an input range set up to read from the file handle one line
at a time. Each line will be newly allocated. $(D front) will cache
its value to allow repeated calls without unnecessary allocations.
Note: Due to caching byLineCopy can be more memory-efficient than
$(D File.byLine.map!idup).
The element type for the range will be $(D Char[]). Range
primitives may throw $(D StdioException) on I/O error.
Params:
Char = Character type for each line, defaulting to $(D immutable char).
keepTerminator = Use $(D Yes.keepTerminator) to include the
terminator at the end of each line.
terminator = Line separator ($(D '\n') by default). Use
$(REF newline, std,ascii) for portability (unless the file was opened in
text mode).
Example:
----
import std.algorithm, std.array, std.stdio;
// Print sorted lines of a file.
void main()
{
auto sortedLines = File("file.txt") // Open for reading
.byLineCopy() // Read persistent lines
.array() // into an array
.sort(); // then sort them
foreach (line; sortedLines)
writeln(line);
}
----
See_Also:
$(REF readText, std,file)
*/
auto byLineCopy(Terminator = char, Char = immutable char)
(KeepTerminator keepTerminator = No.keepTerminator,
Terminator terminator = '\n')
if (isScalarType!Terminator)
{
return ByLineCopy!(Char, Terminator)(this, keepTerminator, terminator);
}
/// ditto
auto byLineCopy(Terminator, Char = immutable char)
(KeepTerminator keepTerminator, Terminator terminator)
if (is(Unqual!(ElementEncodingType!Terminator) == Unqual!Char))
{
return ByLineCopy!(Char, Terminator)(this, keepTerminator, terminator);
}
@safe unittest
{
static assert(is(typeof(File("").byLine.front) == char[]));
static assert(is(typeof(File("").byLineCopy.front) == string));
static assert(
is(typeof(File("").byLineCopy!(char, char).front) == char[]));
}
@system unittest
{
import std.algorithm.comparison : equal;
static import std.file;
scope(failure) printf("Failed test at line %d\n", __LINE__);
auto deleteme = testFilename();
std.file.write(deleteme, "");
scope(success) std.file.remove(deleteme);
// Test empty file
auto f = File(deleteme);
foreach (line; f.byLine())
{
assert(false);
}
f.detach();
assert(!f.isOpen);
void test(Terminator)(string txt, in string[] witness,
KeepTerminator kt, Terminator term, bool popFirstLine = false)
{
import std.algorithm.sorting : sort;
import std.array : array;
import std.conv : text;
import std.range.primitives : walkLength;
uint i;
std.file.write(deleteme, txt);
auto f = File(deleteme);
scope(exit)
{
f.close();
assert(!f.isOpen);
}
auto lines = f.byLine(kt, term);
if (popFirstLine)
{
lines.popFront();
i = 1;
}
assert(lines.empty || lines.front is lines.front);
foreach (line; lines)
{
assert(line == witness[i++]);
}
assert(i == witness.length, text(i, " != ", witness.length));
// Issue 11830
auto walkedLength = File(deleteme).byLine(kt, term).walkLength;
assert(walkedLength == witness.length, text(walkedLength, " != ", witness.length));
// test persistent lines
assert(File(deleteme).byLineCopy(kt, term).array.sort() == witness.dup.sort());
}
KeepTerminator kt = No.keepTerminator;
test("", null, kt, '\n');
test("\n", [ "" ], kt, '\n');
test("asd\ndef\nasdf", [ "asd", "def", "asdf" ], kt, '\n');
test("asd\ndef\nasdf", [ "asd", "def", "asdf" ], kt, '\n', true);
test("asd\ndef\nasdf\n", [ "asd", "def", "asdf" ], kt, '\n');
test("foo", [ "foo" ], kt, '\n', true);
test("bob\r\nmarge\r\nsteve\r\n", ["bob", "marge", "steve"],
kt, "\r\n");
test("sue\r", ["sue"], kt, '\r');
kt = Yes.keepTerminator;
test("", null, kt, '\n');
test("\n", [ "\n" ], kt, '\n');
test("asd\ndef\nasdf", [ "asd\n", "def\n", "asdf" ], kt, '\n');
test("asd\ndef\nasdf\n", [ "asd\n", "def\n", "asdf\n" ], kt, '\n');
test("asd\ndef\nasdf\n", [ "asd\n", "def\n", "asdf\n" ], kt, '\n', true);
test("foo", [ "foo" ], kt, '\n');
test("bob\r\nmarge\r\nsteve\r\n", ["bob\r\n", "marge\r\n", "steve\r\n"],
kt, "\r\n");
test("sue\r", ["sue\r"], kt, '\r');
}
@system unittest
{
import std.algorithm.comparison : equal;
import std.range : drop, take;
version(Win64)
{
static import std.file;
/* the C function tmpfile doesn't seem to work, even when called from C */
auto deleteme = testFilename();
auto file = File(deleteme, "w+");
scope(success) std.file.remove(deleteme);
}
else version(CRuntime_Bionic)
{
static import std.file;
/* the C function tmpfile doesn't work when called from a shared
library apk:
https://code.google.com/p/android/issues/detail?id=66815 */
auto deleteme = testFilename();
auto file = File(deleteme, "w+");
scope(success) std.file.remove(deleteme);
}
else
auto file = File.tmpfile();
file.write("1\n2\n3\n");
// bug 9599
file.rewind();
File.ByLineImpl!(char, char) fbl = file.byLine();
auto fbl2 = fbl;
assert(fbl.front == "1");
assert(fbl.front is fbl2.front);
assert(fbl.take(1).equal(["1"]));
assert(fbl.equal(["2", "3"]));
assert(fbl.empty);
assert(file.isOpen); // we still have a valid reference
file.rewind();
fbl = file.byLine();
assert(!fbl.drop(2).empty);
assert(fbl.equal(["3"]));
assert(fbl.empty);
assert(file.isOpen);
file.detach();
assert(!file.isOpen);
}
@system unittest
{
static import std.file;
auto deleteme = testFilename();
std.file.write(deleteme, "hi");
scope(success) std.file.remove(deleteme);
auto blc = File(deleteme).byLineCopy;
assert(!blc.empty);
// check front is cached
assert(blc.front is blc.front);
}
/**
Creates an input range set up to parse one line at a time from the file
into a tuple.
Range primitives may throw $(D StdioException) on I/O error.
Params:
format = tuple record $(REF_ALTTEXT _format, formattedRead, std, _format)
Returns:
The input range set up to parse one line at a time into a record tuple.
See_Also:
It is similar to $(LREF byLine) and uses
$(REF_ALTTEXT _format, formattedRead, std, _format) under the hood.
*/
template byRecord(Fields...)
{
auto byRecord(string format)
{
return ByRecordImpl!(Fields)(this, format);
}
}
///
@system unittest
{
static import std.file;
import std.typecons : tuple;
// prepare test file
auto testFile = std.file.deleteme();
scope(failure) printf("Failed test at line %d\n", __LINE__);
std.file.write(testFile, "1 2\n4 1\n5 100");
scope(exit) std.file.remove(testFile);
File f = File(testFile);
scope(exit) f.close();
auto expected = [tuple(1, 2), tuple(4, 1), tuple(5, 100)];
uint i;
foreach (e; f.byRecord!(int, int)("%s %s"))
{
assert(e == expected[i++]);
}
}
// Note: This was documented until 2013/08
/*
* Range that reads a chunk at a time.
*/
private struct ByChunkImpl
{
private:
File file_;
ubyte[] chunk_;
void prime()
{
chunk_ = file_.rawRead(chunk_);
if (chunk_.length == 0)
file_.detach();
}
public:
this(File file, size_t size)
{
this(file, new ubyte[](size));
}
this(File file, ubyte[] buffer)
{
import std.exception : enforce;
enforce(buffer.length, "size must be larger than 0");
file_ = file;
chunk_ = buffer;
prime();
}
// $(D ByChunk)'s input range primitive operations.
@property nothrow
bool empty() const
{
return !file_.isOpen;
}
/// Ditto
@property nothrow
ubyte[] front()
{
version(assert)
{
import core.exception : RangeError;
if (empty)
throw new RangeError();
}
return chunk_;
}
/// Ditto
void popFront()
{
version(assert)
{
import core.exception : RangeError;
if (empty)
throw new RangeError();
}
prime();
}
}
// @@@DEPRECATED_2019-01@@@
deprecated("Use .byChunk")
struct ByChunk
{
ByChunkImpl payload;
alias payload this;
}
/**
Returns an input range set up to read from the file handle a chunk at a
time.
The element type for the range will be $(D ubyte[]). Range primitives
may throw $(D StdioException) on I/O error.
Example:
---------
void main()
{
// Read standard input 4KB at a time
foreach (ubyte[] buffer; stdin.byChunk(4096))
{
... use buffer ...
}
}
---------
The parameter may be a number (as shown in the example above) dictating the
size of each chunk. Alternatively, $(D byChunk) accepts a
user-provided buffer that it uses directly.
Example:
---------
void main()
{
// Read standard input 4KB at a time
foreach (ubyte[] buffer; stdin.byChunk(new ubyte[4096]))
{
... use buffer ...
}
}
---------
In either case, the content of the buffer is reused across calls. That means
$(D front) will not persist after $(D popFront) is called, so if retention is
needed, the caller must copy its contents (e.g. by calling $(D buffer.dup)).
In the example above, $(D buffer.length) is 4096 for all iterations, except
for the last one, in which case $(D buffer.length) may be less than 4096 (but
always greater than zero).
With the mentioned limitations, $(D byChunk) works with any algorithm
compatible with input ranges.
Example:
---
// Efficient file copy, 1MB at a time.
import std.algorithm, std.stdio;
void main()
{
stdin.byChunk(1024 * 1024).copy(stdout.lockingTextWriter());
}
---
$(REF joiner, std,algorithm,iteration) can be used to join chunks together into
a single range lazily.
Example:
---
import std.algorithm, std.stdio;
void main()
{
//Range of ranges
static assert(is(typeof(stdin.byChunk(4096).front) == ubyte[]));
//Range of elements
static assert(is(typeof(stdin.byChunk(4096).joiner.front) == ubyte));
}
---
Returns: A call to $(D byChunk) returns a range initialized with the $(D File)
object and the appropriate buffer.
Throws: If the user-provided size is zero or the user-provided buffer
is empty, throws an $(D Exception). In case of an I/O error throws
$(D StdioException).
*/
auto byChunk(size_t chunkSize)
{
return ByChunkImpl(this, chunkSize);
}
/// Ditto
auto byChunk(ubyte[] buffer)
{
return ByChunkImpl(this, buffer);
}
@system unittest
{
static import std.file;
scope(failure) printf("Failed test at line %d\n", __LINE__);
auto deleteme = testFilename();
std.file.write(deleteme, "asd\ndef\nasdf");
auto witness = ["asd\n", "def\n", "asdf" ];
auto f = File(deleteme);
scope(exit)
{
f.close();
assert(!f.isOpen);
std.file.remove(deleteme);
}
uint i;
foreach (chunk; f.byChunk(4))
assert(chunk == cast(ubyte[]) witness[i++]);
assert(i == witness.length);
}
@system unittest
{
static import std.file;
scope(failure) printf("Failed test at line %d\n", __LINE__);
auto deleteme = testFilename();
std.file.write(deleteme, "asd\ndef\nasdf");
auto witness = ["asd\n", "def\n", "asdf" ];
auto f = File(deleteme);
scope(exit)
{
f.close();
assert(!f.isOpen);
std.file.remove(deleteme);
}
uint i;
foreach (chunk; f.byChunk(new ubyte[4]))
assert(chunk == cast(ubyte[]) witness[i++]);
assert(i == witness.length);
}
// Note: This was documented until 2013/08
/*
$(D Range) that locks the file and allows fast writing to it.
*/
struct LockingTextWriter
{
private:
import std.range.primitives : ElementType, isInfinite, isInputRange;
// Access the FILE* handle through the 'file_' member
// to keep the object alive through refcounting
File file_;
// the unshared version of FILE* handle, extracted from the File object
@property _iobuf* handle_() @trusted { return cast(_iobuf*) file_._p.handle; }
// the file's orientation (byte- or wide-oriented)
int orientation_;
public:
this(ref File f) @trusted
{
import core.stdc.wchar_ : fwide;
import std.exception : enforce;
enforce(f._p && f._p.handle, "Attempting to write to closed File");
file_ = f;
FILE* fps = f._p.handle;
orientation_ = fwide(fps, 0);
FLOCK(fps);
}
~this() @trusted
{
if (auto p = file_._p)
{
if (p.handle) FUNLOCK(p.handle);
}
}
this(this) @trusted
{
if (auto p = file_._p)
{
if (p.handle) FLOCK(p.handle);
}
}
/// Range primitive implementations.
void put(A)(A writeme)
if ((isSomeChar!(Unqual!(ElementType!A)) ||
is(ElementType!A : const(ubyte))) &&
isInputRange!A &&
!isInfinite!A)
{
import std.exception : errnoEnforce;
alias C = ElementEncodingType!A;
static assert(!is(C == void));
static if (isSomeString!A && C.sizeof == 1 || is(A : const(ubyte)[]))
{
if (orientation_ <= 0)
{
//file.write(writeme); causes infinite recursion!!!
//file.rawWrite(writeme);
auto result = trustedFwrite(file_._p.handle, writeme);
if (result != writeme.length) errnoEnforce(0);
return;
}
}
// put each element in turn.
foreach (c; writeme)
{
put(c);
}
}
/// ditto
void put(C)(C c) @safe if (isSomeChar!C || is(C : const(ubyte)))
{
import std.traits : Parameters;
static auto trustedFPUTC(int ch, _iobuf* h) @trusted
{
return FPUTC(ch, h);
}
static auto trustedFPUTWC(Parameters!FPUTWC[0] ch, _iobuf* h) @trusted
{
return FPUTWC(ch, h);
}
static if (c.sizeof == 1)
{
// simple char
if (orientation_ <= 0) trustedFPUTC(c, handle_);
else trustedFPUTWC(c, handle_);
}
else static if (c.sizeof == 2)
{
import std.utf : encode;
if (orientation_ <= 0)
{
if (c <= 0x7F)
{
trustedFPUTC(c, handle_);
}
else
{
char[4] buf;
immutable size = encode(buf, c);
foreach (i ; 0 .. size)
trustedFPUTC(buf[i], handle_);
}
}
else
{
trustedFPUTWC(c, handle_);
}
}
else // 32-bit characters
{
import std.utf : encode;
if (orientation_ <= 0)
{
if (c <= 0x7F)
{
trustedFPUTC(c, handle_);
}
else
{
char[4] buf = void;
immutable len = encode(buf, c);
foreach (i ; 0 .. len)
trustedFPUTC(buf[i], handle_);
}
}
else
{
version (Windows)
{
import std.utf : isValidDchar;
assert(isValidDchar(c));
if (c <= 0xFFFF)
{
trustedFPUTWC(c, handle_);
}
else
{
trustedFPUTWC(cast(wchar)
((((c - 0x10000) >> 10) & 0x3FF)
+ 0xD800), handle_);
trustedFPUTWC(cast(wchar)
(((c - 0x10000) & 0x3FF) + 0xDC00),
handle_);
}
}
else version (Posix)
{
trustedFPUTWC(c, handle_);
}
else
{
static assert(0);
}
}
}
}
}
/**
* Output range which locks the file when created, and unlocks the file when it goes
* out of scope.
*
* Returns: An $(REF_ALTTEXT output range, isOutputRange, std, range, primitives)
* which accepts string types, `ubyte[]`, individual character types, and
* individual `ubyte`s.
*
* Note: Writing either arrays of `char`s or `ubyte`s is faster than
* writing each character individually from a range. For large amounts of data,
* writing the contents in chunks using an intermediary array can result
* in a speed increase.
*
* Throws: $(REF UTFException, std, utf) if the data given is a `char` range
* and it contains malformed UTF data.
*
* See_Also: $(LREF byChunk) for an example.
*/
auto lockingTextWriter() @safe
{
return LockingTextWriter(this);
}
// An output range which optionally locks the file and puts it into
// binary mode (similar to rawWrite). Because it needs to restore
// the file mode on destruction, it is RefCounted on Windows.
struct BinaryWriterImpl(bool locking)
{
import std.traits : hasIndirections;
private:
// Access the FILE* handle through the 'file_' member
// to keep the object alive through refcounting
File file_;
string name;
version (Windows)
{
int fd, oldMode;
version (DIGITAL_MARS_STDIO)
ubyte oldInfo;
}
package:
this(ref File f)
{
import std.exception : enforce;
file_ = f;
enforce(f._p && f._p.handle);
name = f._name;
FILE* fps = f._p.handle;
static if (locking)
FLOCK(fps);
version (Windows)
{
.fflush(fps); // before changing translation mode
fd = ._fileno(fps);
oldMode = ._setmode(fd, _O_BINARY);
version (DIGITAL_MARS_STDIO)
{
import core.atomic : atomicOp;
// @@@BUG@@@ 4243
oldInfo = __fhnd_info[fd];
atomicOp!"&="(__fhnd_info[fd], ~FHND_TEXT);
}
}
}
public:
~this()
{
if (!file_._p || !file_._p.handle)
return;
FILE* fps = file_._p.handle;
version (Windows)
{
.fflush(fps); // before restoring translation mode
version (DIGITAL_MARS_STDIO)
{
// @@@BUG@@@ 4243
__fhnd_info[fd] = oldInfo;
}
._setmode(fd, oldMode);
}
FUNLOCK(fps);
}
void rawWrite(T)(in T[] buffer)
{
import std.conv : text;
import std.exception : errnoEnforce;
auto result = trustedFwrite(file_._p.handle, buffer);
if (result == result.max) result = 0;
errnoEnforce(result == buffer.length,
text("Wrote ", result, " instead of ", buffer.length,
" objects of type ", T.stringof, " to file `",
name, "'"));
}
version (Windows)
{
@disable this(this);
}
else
{
this(this)
{
if (auto p = file_._p)
{
if (p.handle) FLOCK(p.handle);
}
}
}
void put(T)(auto ref in T value)
if (!hasIndirections!T &&
!isInputRange!T)
{
rawWrite((&value)[0 .. 1]);
}
void put(T)(in T[] array)
if (!hasIndirections!T &&
!isInputRange!T)
{
rawWrite(array);
}
}
/** Returns an output range that locks the file and allows fast writing to it.
Example:
Produce a grayscale image of the $(LINK2 https://en.wikipedia.org/wiki/Mandelbrot_set, Mandelbrot set)
in binary $(LINK2 https://en.wikipedia.org/wiki/Netpbm_format, Netpbm format) to standard output.
---
import std.algorithm, std.range, std.stdio;
void main()
{
enum size = 500;
writef("P5\n%d %d %d\n", size, size, ubyte.max);
iota(-1, 3, 2.0/size).map!(y =>
iota(-1.5, 0.5, 2.0/size).map!(x =>
cast(ubyte)(1+
recurrence!((a, n) => x + y*1i + a[n-1]^^2)(0+0i)
.take(ubyte.max)
.countUntil!(z => z.re^^2 + z.im^^2 > 4))
)
)
.copy(stdout.lockingBinaryWriter);
}
---
*/
auto lockingBinaryWriter()
{
alias LockingBinaryWriterImpl = BinaryWriterImpl!true;
version (Windows)
{
import std.typecons : RefCounted;
alias LockingBinaryWriter = RefCounted!LockingBinaryWriterImpl;
}
else
alias LockingBinaryWriter = LockingBinaryWriterImpl;
return LockingBinaryWriter(this);
}
@system unittest
{
import std.algorithm.mutation : reverse;
import std.exception : collectException;
static import std.file;
import std.range : only, retro;
import std.string : format;
auto deleteme = testFilename();
scope(exit) collectException(std.file.remove(deleteme));
{
auto writer = File(deleteme, "wb").lockingBinaryWriter();
auto input = File(deleteme, "rb");
ubyte[1] byteIn = [42];
writer.rawWrite(byteIn);
destroy(writer);
ubyte[1] byteOut = input.rawRead(new ubyte[1]);
assert(byteIn[0] == byteOut[0]);
}
auto output = File(deleteme, "wb");
auto writer = output.lockingBinaryWriter();
auto input = File(deleteme, "rb");
T[] readExact(T)(T[] buf)
{
auto result = input.rawRead(buf);
assert(result.length == buf.length,
"Read %d out of %d bytes"
.format(result.length, buf.length));
return result;
}
// test raw values
ubyte byteIn = 42;
byteIn.only.copy(writer); output.flush();
ubyte byteOut = readExact(new ubyte[1])[0];
assert(byteIn == byteOut);
// test arrays
ubyte[] bytesIn = [1, 2, 3, 4, 5];
bytesIn.copy(writer); output.flush();
ubyte[] bytesOut = readExact(new ubyte[bytesIn.length]);
scope(failure) .writeln(bytesOut);
assert(bytesIn == bytesOut);
// test ranges of values
bytesIn.retro.copy(writer); output.flush();
bytesOut = readExact(bytesOut);
bytesOut.reverse();
assert(bytesIn == bytesOut);
// test string
"foobar".copy(writer); output.flush();
char[] charsOut = readExact(new char[6]);
assert(charsOut == "foobar");
// test ranges of arrays
only("foo", "bar").copy(writer); output.flush();
charsOut = readExact(charsOut);
assert(charsOut == "foobar");
// test that we are writing arrays as is,
// without UTF-8 transcoding
"foo"d.copy(writer); output.flush();
dchar[] dcharsOut = readExact(new dchar[3]);
assert(dcharsOut == "foo");
}
/// Get the size of the file, ulong.max if file is not searchable, but still throws if an actual error occurs.
@property ulong size() @safe
{
import std.exception : collectException;
ulong pos = void;
if (collectException(pos = tell)) return ulong.max;
scope(exit) seek(pos);
seek(0, SEEK_END);
return tell;
}
}
@system unittest
{
@system struct SystemToString
{
string toString()
{
return "system";
}
}
@trusted struct TrustedToString
{
string toString()
{
return "trusted";
}
}
@safe struct SafeToString
{
string toString()
{
return "safe";
}
}
@system void systemTests()
{
//system code can write to files/stdout with anything!
if (false)
{
auto f = File();
f.write("just a string");
f.write("string with arg: ", 47);
f.write(SystemToString());
f.write(TrustedToString());
f.write(SafeToString());
write("just a string");
write("string with arg: ", 47);
write(SystemToString());
write(TrustedToString());
write(SafeToString());
f.writeln("just a string");
f.writeln("string with arg: ", 47);
f.writeln(SystemToString());
f.writeln(TrustedToString());
f.writeln(SafeToString());
writeln("just a string");
writeln("string with arg: ", 47);
writeln(SystemToString());
writeln(TrustedToString());
writeln(SafeToString());
f.writef("string with arg: %s", 47);
f.writef("%s", SystemToString());
f.writef("%s", TrustedToString());
f.writef("%s", SafeToString());
writef("string with arg: %s", 47);
writef("%s", SystemToString());
writef("%s", TrustedToString());
writef("%s", SafeToString());
f.writefln("string with arg: %s", 47);
f.writefln("%s", SystemToString());
f.writefln("%s", TrustedToString());
f.writefln("%s", SafeToString());
writefln("string with arg: %s", 47);
writefln("%s", SystemToString());
writefln("%s", TrustedToString());
writefln("%s", SafeToString());
}
}
@safe void safeTests()
{
auto f = File();
//safe code can write to files only with @safe and @trusted code...
if (false)
{
f.write("just a string");
f.write("string with arg: ", 47);
f.write(TrustedToString());
f.write(SafeToString());
write("just a string");
write("string with arg: ", 47);
write(TrustedToString());
write(SafeToString());
f.writeln("just a string");
f.writeln("string with arg: ", 47);
f.writeln(TrustedToString());
f.writeln(SafeToString());
writeln("just a string");
writeln("string with arg: ", 47);
writeln(TrustedToString());
writeln(SafeToString());
f.writef("string with arg: %s", 47);
f.writef("%s", TrustedToString());
f.writef("%s", SafeToString());
writef("string with arg: %s", 47);
writef("%s", TrustedToString());
writef("%s", SafeToString());
f.writefln("string with arg: %s", 47);
f.writefln("%s", TrustedToString());
f.writefln("%s", SafeToString());
writefln("string with arg: %s", 47);
writefln("%s", TrustedToString());
writefln("%s", SafeToString());
}
static assert(!__traits(compiles, f.write(SystemToString().toString())));
static assert(!__traits(compiles, f.writeln(SystemToString())));
static assert(!__traits(compiles, f.writef("%s", SystemToString())));
static assert(!__traits(compiles, f.writefln("%s", SystemToString())));
static assert(!__traits(compiles, write(SystemToString().toString())));
static assert(!__traits(compiles, writeln(SystemToString())));
static assert(!__traits(compiles, writef("%s", SystemToString())));
static assert(!__traits(compiles, writefln("%s", SystemToString())));
}
systemTests();
safeTests();
}
@safe unittest
{
import std.exception : collectException;
static import std.file;
auto deleteme = testFilename();
scope(exit) collectException(std.file.remove(deleteme));
std.file.write(deleteme, "1 2 3");
auto f = File(deleteme);
assert(f.size == 5);
assert(f.tell == 0);
}
@system unittest
{
// @system due to readln
static import std.file;
import std.range : chain, only, repeat;
import std.range.primitives : isOutputRange;
auto deleteme = testFilename();
scope(exit) std.file.remove(deleteme);
{
auto writer = File(deleteme, "w").lockingTextWriter();
static assert(isOutputRange!(typeof(writer), dchar));
writer.put("日本語");
writer.put("日本語"w);
writer.put("日本語"d);
writer.put('日');
writer.put(chain(only('本'), only('語')));
writer.put(repeat('#', 12)); // BUG 11945
writer.put(cast(immutable(ubyte)[])"日本語"); // Bug 17229
}
assert(File(deleteme).readln() == "日本語日本語日本語日本語############日本語");
}
@safe unittest
{
import std.exception : collectException;
auto e = collectException({ File f; f.writeln("Hello!"); }());
assert(e && e.msg == "Attempting to write to closed File");
}
/// Used to specify the lock type for $(D File.lock) and $(D File.tryLock).
enum LockType
{
/**
* Specifies a _read (shared) lock. A _read lock denies all processes
* write access to the specified region of the file, including the
* process that first locks the region. All processes can _read the
* locked region. Multiple simultaneous _read locks are allowed, as
* long as there are no exclusive locks.
*/
read,
/**
* Specifies a read/write (exclusive) lock. A read/write lock denies all
* other processes both read and write access to the locked file region.
* If a segment has an exclusive lock, it may not have any shared locks
* or other exclusive locks.
*/
readWrite
}
struct LockingTextReader
{
private File _f;
private char _front;
private bool _hasChar;
this(File f)
{
import std.exception : enforce;
enforce(f.isOpen, "LockingTextReader: File must be open");
_f = f;
FLOCK(_f._p.handle);
}
this(this)
{
FLOCK(_f._p.handle);
}
~this()
{
if (_hasChar)
ungetc(_front, cast(FILE*)_f._p.handle);
// File locking has its own reference count
if (_f.isOpen) FUNLOCK(_f._p.handle);
}
void opAssign(LockingTextReader r)
{
import std.algorithm.mutation : swap;
swap(this, r);
}
@property bool empty()
{
if (!_hasChar)
{
if (!_f.isOpen || _f.eof)
return true;
immutable int c = FGETC(cast(_iobuf*) _f._p.handle);
if (c == EOF)
{
.destroy(_f);
return true;
}
_front = cast(char) c;
_hasChar = true;
}
return false;
}
@property char front()
{
if (!_hasChar)
{
version(assert)
{
import core.exception : RangeError;
if (empty)
throw new RangeError();
}
else
{
empty;
}
}
return _front;
}
void popFront()
{
if (!_hasChar)
empty;
_hasChar = false;
}
}
@system unittest
{
// @system due to readf
static import std.file;
import std.range.primitives : isInputRange;
static assert(isInputRange!LockingTextReader);
auto deleteme = testFilename();
std.file.write(deleteme, "1 2 3");
scope(exit) std.file.remove(deleteme);
int x;
auto f = File(deleteme);
f.readf("%s ", &x);
assert(x == 1);
f.readf("%d ", &x);
assert(x == 2);
f.readf("%d ", &x);
assert(x == 3);
}
@system unittest // bugzilla 13686
{
import std.algorithm.comparison : equal;
static import std.file;
import std.utf : byDchar;
auto deleteme = testFilename();
std.file.write(deleteme, "Тест");
scope(exit) std.file.remove(deleteme);
string s;
File(deleteme).readf("%s", &s);
assert(s == "Тест");
auto ltr = LockingTextReader(File(deleteme)).byDchar;
assert(equal(ltr, "Тест".byDchar));
}
@system unittest // bugzilla 12320
{
static import std.file;
auto deleteme = testFilename();
std.file.write(deleteme, "ab");
scope(exit) std.file.remove(deleteme);
auto ltr = LockingTextReader(File(deleteme));
assert(ltr.front == 'a');
ltr.popFront();
assert(ltr.front == 'b');
ltr.popFront();
assert(ltr.empty);
}
@system unittest // bugzilla 14861
{
// @system due to readf
static import std.file;
auto deleteme = testFilename();
File fw = File(deleteme, "w");
for (int i; i != 5000; i++)
fw.writeln(i, ";", "Иванов;Пётр;Петрович");
fw.close();
scope(exit) std.file.remove(deleteme);
// Test read
File fr = File(deleteme, "r");
scope (exit) fr.close();
int nom; string fam, nam, ot;
// Error format read
while (!fr.eof)
fr.readf("%s;%s;%s;%s\n", &nom, &fam, &nam, &ot);
}
/**
* Indicates whether $(D T) is a file handle, i.e. the type
* is implicitly convertable to $(LREF File) or a pointer to a
* $(REF FILE, core,stdc,stdio).
*
* Returns:
* `true` if `T` is a file handle, `false` otherwise.
*/
template isFileHandle(T)
{
enum isFileHandle = is(T : FILE*) ||
is(T : File);
}
///
@safe unittest
{
static assert(isFileHandle!(FILE*));
static assert(isFileHandle!(File));
}
/**
* Property used by writeln/etc. so it can infer @safe since stdout is __gshared
*/
private @property File trustedStdout() @trusted
{
return stdout;
}
/***********************************
For each argument $(D arg) in $(D args), format the argument (using
$(REF to, std,conv)) and write the resulting
string to $(D args[0]). A call without any arguments will fail to
compile.
Params:
args = the items to write to `stdout`
Throws: In case of an I/O error, throws an $(D StdioException).
Example:
Reads `stdin` and writes it to `stdout` with an argument
counter.
---
import std.stdio;
void main()
{
string line;
for (size_t count = 0; (line = readln) !is null; count++)
{
write("Input ", count, ": ", line, "\n");
}
}
---
*/
void write(T...)(T args)
if (!is(T[0] : File))
{
trustedStdout.write(args);
}
@system unittest
{
static import std.file;
scope(failure) printf("Failed test at line %d\n", __LINE__);
void[] buf;
if (false) write(buf);
// test write
auto deleteme = testFilename();
auto f = File(deleteme, "w");
f.write("Hello, ", "world number ", 42, "!");
f.close();
scope(exit) { std.file.remove(deleteme); }
assert(cast(char[]) std.file.read(deleteme) == "Hello, world number 42!");
}
/***********************************
* Equivalent to `write(args, '\n')`. Calling `writeln` without
* arguments is valid and just prints a newline to the standard
* output.
*
* Params:
* args = the items to write to `stdout`
*
* Throws:
* In case of an I/O error, throws an $(LREF StdioException).
* Example:
* Reads $(D stdin) and writes it to $(D stdout) with a argument
* counter.
---
import std.stdio;
void main()
{
string line;
for (size_t count = 0; (line = readln) !is null; count++)
{
writeln("Input ", count, ": ", line);
}
}
---
*/
void writeln(T...)(T args)
{
import std.traits : isAggregateType;
static if (T.length == 0)
{
import std.exception : enforce;
enforce(fputc('\n', .trustedStdout._p.handle) != EOF, "fputc failed");
}
else static if (T.length == 1 &&
is(typeof(args[0]) : const(char)[]) &&
!is(typeof(args[0]) == enum) &&
!is(Unqual!(typeof(args[0])) == typeof(null)) &&
!isAggregateType!(typeof(args[0])))
{
import std.traits : isStaticArray;
// Specialization for strings - a very frequent case
auto w = .trustedStdout.lockingTextWriter();
static if (isStaticArray!(typeof(args[0])))
{
w.put(args[0][]);
}
else
{
w.put(args[0]);
}
w.put('\n');
}
else
{
// Most general instance
trustedStdout.write(args, '\n');
}
}
@safe unittest
{
// Just make sure the call compiles
if (false) writeln();
if (false) writeln("wyda");
// bug 8040
if (false) writeln(null);
if (false) writeln(">", null, "<");
// Bugzilla 14041
if (false)
{
char[8] a;
writeln(a);
}
}
@system unittest
{
static import std.file;
scope(failure) printf("Failed test at line %d\n", __LINE__);
// test writeln
auto deleteme = testFilename();
auto f = File(deleteme, "w");
scope(exit) { std.file.remove(deleteme); }
f.writeln("Hello, ", "world number ", 42, "!");
f.close();
version (Windows)
assert(cast(char[]) std.file.read(deleteme) ==
"Hello, world number 42!\r\n");
else
assert(cast(char[]) std.file.read(deleteme) ==
"Hello, world number 42!\n");
// test writeln on stdout
auto saveStdout = stdout;
scope(exit) stdout = saveStdout;
stdout.open(deleteme, "w");
writeln("Hello, ", "world number ", 42, "!");
stdout.close();
version (Windows)
assert(cast(char[]) std.file.read(deleteme) ==
"Hello, world number 42!\r\n");
else
assert(cast(char[]) std.file.read(deleteme) ==
"Hello, world number 42!\n");
stdout.open(deleteme, "w");
writeln("Hello!"c);
writeln("Hello!"w); // bug 8386
writeln("Hello!"d); // bug 8386
writeln("embedded\0null"c); // bug 8730
stdout.close();
version (Windows)
assert(cast(char[]) std.file.read(deleteme) ==
"Hello!\r\nHello!\r\nHello!\r\nembedded\0null\r\n");
else
assert(cast(char[]) std.file.read(deleteme) ==
"Hello!\nHello!\nHello!\nembedded\0null\n");
}
@system unittest
{
static import std.file;
auto deleteme = testFilename();
auto f = File(deleteme, "w");
scope(exit) { std.file.remove(deleteme); }
enum EI : int { A, B }
enum ED : double { A = 0, B } // NOTE: explicit initialization to 0 required during Enum init deprecation cycle
enum EC : char { A = 0, B } // NOTE: explicit initialization to 0 required during Enum init deprecation cycle
enum ES : string { A = "aaa", B = "bbb" }
f.writeln(EI.A); // false, but A on 2.058
f.writeln(EI.B); // true, but B on 2.058
f.writeln(ED.A); // A
f.writeln(ED.B); // B
f.writeln(EC.A); // A
f.writeln(EC.B); // B
f.writeln(ES.A); // A
f.writeln(ES.B); // B
f.close();
version (Windows)
assert(cast(char[]) std.file.read(deleteme) ==
"A\r\nB\r\nA\r\nB\r\nA\r\nB\r\nA\r\nB\r\n");
else
assert(cast(char[]) std.file.read(deleteme) ==
"A\nB\nA\nB\nA\nB\nA\nB\n");
}
@system unittest
{
static auto useInit(T)(T ltw)
{
T val;
val = ltw;
val = T.init;
return val;
}
useInit(stdout.lockingTextWriter());
}
/***********************************
Writes formatted data to standard output (without a trailing newline).
Params:
fmt = The $(REF_ALTTEXT format string, formattedWrite, std, _format).
When passed as a compile-time argument, the string will be statically checked
against the argument types passed.
args = Items to write.
Note: In older versions of Phobos, it used to be possible to write:
------
writef(stderr, "%s", "message");
------
to print a message to $(D stderr). This syntax is no longer supported, and has
been superceded by:
------
stderr.writef("%s", "message");
------
*/
void writef(alias fmt, A...)(A args)
if (isSomeString!(typeof(fmt)))
{
import std.format : checkFormatException;
alias e = checkFormatException!(fmt, A);
static assert(!e, e.msg);
return .writef(fmt, args);
}
/// ditto
void writef(Char, A...)(in Char[] fmt, A args)
{
trustedStdout.writef(fmt, args);
}
@system unittest
{
static import std.file;
scope(failure) printf("Failed test at line %d\n", __LINE__);
// test writef
auto deleteme = testFilename();
auto f = File(deleteme, "w");
scope(exit) { std.file.remove(deleteme); }
f.writef!"Hello, %s world number %s!"("nice", 42);
f.close();
assert(cast(char[]) std.file.read(deleteme) == "Hello, nice world number 42!");
// test write on stdout
auto saveStdout = stdout;
scope(exit) stdout = saveStdout;
stdout.open(deleteme, "w");
writef!"Hello, %s world number %s!"("nice", 42);
stdout.close();
assert(cast(char[]) std.file.read(deleteme) == "Hello, nice world number 42!");
}
/***********************************
* Equivalent to $(D writef(fmt, args, '\n')).
*/
void writefln(alias fmt, A...)(A args)
if (isSomeString!(typeof(fmt)))
{
import std.format : checkFormatException;
alias e = checkFormatException!(fmt, A);
static assert(!e, e.msg);
return .writefln(fmt, args);
}
/// ditto
void writefln(Char, A...)(in Char[] fmt, A args)
{
trustedStdout.writefln(fmt, args);
}
@system unittest
{
static import std.file;
scope(failure) printf("Failed test at line %d\n", __LINE__);
// test File.writefln
auto deleteme = testFilename();
auto f = File(deleteme, "w");
scope(exit) { std.file.remove(deleteme); }
f.writefln!"Hello, %s world number %s!"("nice", 42);
f.close();
version (Windows)
assert(cast(char[]) std.file.read(deleteme) ==
"Hello, nice world number 42!\r\n");
else
assert(cast(char[]) std.file.read(deleteme) ==
"Hello, nice world number 42!\n",
cast(char[]) std.file.read(deleteme));
// test writefln
auto saveStdout = stdout;
scope(exit) stdout = saveStdout;
stdout.open(deleteme, "w");
writefln!"Hello, %s world number %s!"("nice", 42);
stdout.close();
version (Windows)
assert(cast(char[]) std.file.read(deleteme) ==
"Hello, nice world number 42!\r\n");
else
assert(cast(char[]) std.file.read(deleteme) ==
"Hello, nice world number 42!\n");
}
/**
* Reads formatted data from $(D stdin) using $(REF formattedRead, std,_format).
* Params:
* format = The $(REF_ALTTEXT format string, formattedWrite, std, _format).
* When passed as a compile-time argument, the string will be statically checked
* against the argument types passed.
* args = Items to be read.
* Example:
----
// test.d
void main()
{
import std.stdio;
foreach (_; 0 .. 3)
{
int a;
readf!" %d"(a);
writeln(++a);
}
}
----
$(CONSOLE
% echo "1 2 3" | rdmd test.d
2
3
4
)
*/
uint readf(alias format, A...)(auto ref A args)
if (isSomeString!(typeof(format)))
{
import std.format : checkFormatException;
alias e = checkFormatException!(format, A);
static assert(!e, e.msg);
return .readf(format, args);
}
/// ditto
uint readf(A...)(in char[] format, auto ref A args)
{
return stdin.readf(format, args);
}
@system unittest
{
float f;
if (false) readf("%s", &f);
char a;
wchar b;
dchar c;
if (false) readf("%s %s %s", a, b, c);
// backwards compatibility with pointers
if (false) readf("%s %s %s", a, &b, c);
if (false) readf("%s %s %s", &a, &b, &c);
}
/**********************************
* Read line from $(D stdin).
*
* This version manages its own read buffer, which means one memory allocation per call. If you are not
* retaining a reference to the read data, consider the $(D readln(buf)) version, which may offer
* better performance as it can reuse its read buffer.
*
* Returns:
* The line that was read, including the line terminator character.
* Params:
* S = Template parameter; the type of the allocated buffer, and the type returned. Defaults to $(D string).
* terminator = Line terminator (by default, $(D '\n')).
* Note:
* String terminators are not supported due to ambiguity with readln(buf) below.
* Throws:
* $(D StdioException) on I/O error, or $(D UnicodeException) on Unicode conversion error.
* Example:
* Reads $(D stdin) and writes it to $(D stdout).
---
import std.stdio;
void main()
{
string line;
while ((line = readln()) !is null)
write(line);
}
---
*/
S readln(S = string)(dchar terminator = '\n')
if (isSomeString!S)
{
return stdin.readln!S(terminator);
}
/**********************************
* Read line from $(D stdin) and write it to buf[], including terminating character.
*
* This can be faster than $(D line = readln()) because you can reuse
* the buffer for each call. Note that reusing the buffer means that you
* must copy the previous contents if you wish to retain them.
*
* Returns:
* $(D size_t) 0 for end of file, otherwise number of characters read
* Params:
* buf = Buffer used to store the resulting line data. buf is resized as necessary.
* terminator = Line terminator (by default, $(D '\n')). Use $(REF newline, std,ascii)
* for portability (unless the file was opened in text mode).
* Throws:
* $(D StdioException) on I/O error, or $(D UnicodeException) on Unicode conversion error.
* Example:
* Reads $(D stdin) and writes it to $(D stdout).
---
import std.stdio;
void main()
{
char[] buf;
while (readln(buf))
write(buf);
}
---
*/
size_t readln(C)(ref C[] buf, dchar terminator = '\n')
if (isSomeChar!C && is(Unqual!C == C) && !is(C == enum))
{
return stdin.readln(buf, terminator);
}
/** ditto */
size_t readln(C, R)(ref C[] buf, R terminator)
if (isSomeChar!C && is(Unqual!C == C) && !is(C == enum) &&
isBidirectionalRange!R && is(typeof(terminator.front == dchar.init)))
{
return stdin.readln(buf, terminator);
}
@safe unittest
{
import std.meta : AliasSeq;
//we can't actually test readln, so at the very least,
//we test compilability
void foo()
{
readln();
readln('\t');
static foreach (String; AliasSeq!(string, char[], wstring, wchar[], dstring, dchar[]))
{
readln!String();
readln!String('\t');
}
static foreach (String; AliasSeq!(char[], wchar[], dchar[]))
{{
String buf;
readln(buf);
readln(buf, '\t');
readln(buf, "<br />");
}}
}
}
/*
* Convenience function that forwards to $(D core.sys.posix.stdio.fopen)
* (to $(D _wfopen) on Windows)
* with appropriately-constructed C-style strings.
*/
private FILE* fopen(R1, R2)(R1 name, R2 mode = "r")
if ((isInputRange!R1 && isSomeChar!(ElementEncodingType!R1) || isSomeString!R1) &&
(isInputRange!R2 && isSomeChar!(ElementEncodingType!R2) || isSomeString!R2))
{
import std.internal.cstring : tempCString;
auto namez = name.tempCString!FSChar();
auto modez = mode.tempCString!FSChar();
static fopenImpl(const(FSChar)* namez, const(FSChar)* modez) @trusted nothrow @nogc
{
version(Windows)
{
return _wfopen(namez, modez);
}
else version(Posix)
{
/*
* The new opengroup large file support API is transparently
* included in the normal C bindings. http://opengroup.org/platform/lfs.html#1.0
* if _FILE_OFFSET_BITS in druntime is 64, off_t is 64 bit and
* the normal functions work fine. If not, then large file support
* probably isn't available. Do not use the old transitional API
* (the native extern(C) fopen64, http://www.unix.org/version2/whatsnew/lfs20mar.html#3.0)
*/
import core.sys.posix.stdio : fopen;
return fopen(namez, modez);
}
else
{
return .fopen(namez, modez);
}
}
return fopenImpl(namez, modez);
}
version (Posix)
{
/***********************************
* Convenience function that forwards to $(D core.sys.posix.stdio.popen)
* with appropriately-constructed C-style strings.
*/
FILE* popen(R1, R2)(R1 name, R2 mode = "r") @trusted nothrow @nogc
if ((isInputRange!R1 && isSomeChar!(ElementEncodingType!R1) || isSomeString!R1) &&
(isInputRange!R2 && isSomeChar!(ElementEncodingType!R2) || isSomeString!R2))
{
import std.internal.cstring : tempCString;
auto namez = name.tempCString!FSChar();
auto modez = mode.tempCString!FSChar();
static popenImpl(const(FSChar)* namez, const(FSChar)* modez) @trusted nothrow @nogc
{
import core.sys.posix.stdio : popen;
return popen(namez, modez);
}
return popenImpl(namez, modez);
}
}
/*
* Convenience function that forwards to $(D core.stdc.stdio.fwrite)
*/
private auto trustedFwrite(T)(FILE* f, const T[] obj) @trusted
{
return fwrite(obj.ptr, T.sizeof, obj.length, f);
}
/*
* Convenience function that forwards to $(D core.stdc.stdio.fread)
*/
private auto trustedFread(T)(FILE* f, T[] obj) @trusted
{
return fread(obj.ptr, T.sizeof, obj.length, f);
}
/**
* Iterates through the lines of a file by using $(D foreach).
*
* Example:
*
---------
void main()
{
foreach (string line; lines(stdin))
{
... use line ...
}
}
---------
The line terminator ($(D '\n') by default) is part of the string read (it
could be missing in the last line of the file). Several types are
supported for $(D line), and the behavior of $(D lines)
changes accordingly:
$(OL $(LI If $(D line) has type $(D string), $(D
wstring), or $(D dstring), a new string of the respective type
is allocated every read.) $(LI If $(D line) has type $(D
char[]), $(D wchar[]), $(D dchar[]), the line's content
will be reused (overwritten) across reads.) $(LI If $(D line)
has type $(D immutable(ubyte)[]), the behavior is similar to
case (1), except that no UTF checking is attempted upon input.) $(LI
If $(D line) has type $(D ubyte[]), the behavior is
similar to case (2), except that no UTF checking is attempted upon
input.))
In all cases, a two-symbols versions is also accepted, in which case
the first symbol (of integral type, e.g. $(D ulong) or $(D
uint)) tracks the zero-based number of the current line.
Example:
----
foreach (ulong i, string line; lines(stdin))
{
... use line ...
}
----
In case of an I/O error, an $(D StdioException) is thrown.
See_Also:
$(LREF byLine)
*/
struct lines
{
private File f;
private dchar terminator = '\n';
/**
Constructor.
Params:
f = File to read lines from.
terminator = Line separator ($(D '\n') by default).
*/
this(File f, dchar terminator = '\n')
{
this.f = f;
this.terminator = terminator;
}
int opApply(D)(scope D dg)
{
import std.traits : Parameters;
alias Parms = Parameters!(dg);
static if (isSomeString!(Parms[$ - 1]))
{
int result = 0;
static if (is(Parms[$ - 1] : const(char)[]))
alias C = char;
else static if (is(Parms[$ - 1] : const(wchar)[]))
alias C = wchar;
else static if (is(Parms[$ - 1] : const(dchar)[]))
alias C = dchar;
C[] line;
static if (Parms.length == 2)
Parms[0] i = 0;
for (;;)
{
import std.conv : to;
if (!f.readln(line, terminator)) break;
auto copy = to!(Parms[$ - 1])(line);
static if (Parms.length == 2)
{
result = dg(i, copy);
++i;
}
else
{
result = dg(copy);
}
if (result != 0) break;
}
return result;
}
else
{
// raw read
return opApplyRaw(dg);
}
}
// no UTF checking
int opApplyRaw(D)(scope D dg)
{
import std.conv : to;
import std.exception : assumeUnique;
import std.traits : Parameters;
alias Parms = Parameters!(dg);
enum duplicate = is(Parms[$ - 1] : immutable(ubyte)[]);
int result = 1;
int c = void;
FLOCK(f._p.handle);
scope(exit) FUNLOCK(f._p.handle);
ubyte[] buffer;
static if (Parms.length == 2)
Parms[0] line = 0;
while ((c = FGETC(cast(_iobuf*) f._p.handle)) != -1)
{
buffer ~= to!(ubyte)(c);
if (c == terminator)
{
static if (duplicate)
auto arg = assumeUnique(buffer);
else
alias arg = buffer;
// unlock the file while calling the delegate
FUNLOCK(f._p.handle);
scope(exit) FLOCK(f._p.handle);
static if (Parms.length == 1)
{
result = dg(arg);
}
else
{
result = dg(line, arg);
++line;
}
if (result) break;
static if (!duplicate)
buffer.length = 0;
}
}
// can only reach when FGETC returned -1
if (!f.eof) throw new StdioException("Error in reading file"); // error occured
return result;
}
}
@system unittest
{
static import std.file;
import std.meta : AliasSeq;
scope(failure) printf("Failed test at line %d\n", __LINE__);
auto deleteme = testFilename();
scope(exit) { std.file.remove(deleteme); }
alias TestedWith =
AliasSeq!(string, wstring, dstring,
char[], wchar[], dchar[]);
foreach (T; TestedWith)
{
// test looping with an empty file
std.file.write(deleteme, "");
auto f = File(deleteme, "r");
foreach (T line; lines(f))
{
assert(false);
}
f.close();
// test looping with a file with three lines
std.file.write(deleteme, "Line one\nline two\nline three\n");
f.open(deleteme, "r");
uint i = 0;
foreach (T line; lines(f))
{
if (i == 0) assert(line == "Line one\n");
else if (i == 1) assert(line == "line two\n");
else if (i == 2) assert(line == "line three\n");
else assert(false);
++i;
}
f.close();
// test looping with a file with three lines, last without a newline
std.file.write(deleteme, "Line one\nline two\nline three");
f.open(deleteme, "r");
i = 0;
foreach (T line; lines(f))
{
if (i == 0) assert(line == "Line one\n");
else if (i == 1) assert(line == "line two\n");
else if (i == 2) assert(line == "line three");
else assert(false);
++i;
}
f.close();
}
// test with ubyte[] inputs
alias TestedWith2 = AliasSeq!(immutable(ubyte)[], ubyte[]);
foreach (T; TestedWith2)
{
// test looping with an empty file
std.file.write(deleteme, "");
auto f = File(deleteme, "r");
foreach (T line; lines(f))
{
assert(false);
}
f.close();
// test looping with a file with three lines
std.file.write(deleteme, "Line one\nline two\nline three\n");
f.open(deleteme, "r");
uint i = 0;
foreach (T line; lines(f))
{
if (i == 0) assert(cast(char[]) line == "Line one\n");
else if (i == 1) assert(cast(char[]) line == "line two\n",
T.stringof ~ " " ~ cast(char[]) line);
else if (i == 2) assert(cast(char[]) line == "line three\n");
else assert(false);
++i;
}
f.close();
// test looping with a file with three lines, last without a newline
std.file.write(deleteme, "Line one\nline two\nline three");
f.open(deleteme, "r");
i = 0;
foreach (T line; lines(f))
{
if (i == 0) assert(cast(char[]) line == "Line one\n");
else if (i == 1) assert(cast(char[]) line == "line two\n");
else if (i == 2) assert(cast(char[]) line == "line three");
else assert(false);
++i;
}
f.close();
}
static foreach (T; AliasSeq!(ubyte[]))
{
// test looping with a file with three lines, last without a newline
// using a counter too this time
std.file.write(deleteme, "Line one\nline two\nline three");
auto f = File(deleteme, "r");
uint i = 0;
foreach (ulong j, T line; lines(f))
{
if (i == 0) assert(cast(char[]) line == "Line one\n");
else if (i == 1) assert(cast(char[]) line == "line two\n");
else if (i == 2) assert(cast(char[]) line == "line three");
else assert(false);
++i;
}
f.close();
}
}
/**
Iterates through a file a chunk at a time by using $(D foreach).
Example:
---------
void main()
{
foreach (ubyte[] buffer; chunks(stdin, 4096))
{
... use buffer ...
}
}
---------
The content of $(D buffer) is reused across calls. In the
example above, $(D buffer.length) is 4096 for all iterations,
except for the last one, in which case $(D buffer.length) may
be less than 4096 (but always greater than zero).
In case of an I/O error, an $(D StdioException) is thrown.
*/
auto chunks(File f, size_t size)
{
return ChunksImpl(f, size);
}
private struct ChunksImpl
{
private File f;
private size_t size;
// private string fileName; // Currently, no use
this(File f, size_t size)
in
{
assert(size, "size must be larger than 0");
}
do
{
this.f = f;
this.size = size;
}
int opApply(D)(scope D dg)
{
import core.stdc.stdlib : alloca;
enum maxStackSize = 1024 * 16;
ubyte[] buffer = void;
if (size < maxStackSize)
buffer = (cast(ubyte*) alloca(size))[0 .. size];
else
buffer = new ubyte[size];
size_t r = void;
int result = 1;
uint tally = 0;
while ((r = trustedFread(f._p.handle, buffer)) > 0)
{
assert(r <= size);
if (r != size)
{
// error occured
if (!f.eof) throw new StdioException(null);
buffer.length = r;
}
static if (is(typeof(dg(tally, buffer))))
{
if ((result = dg(tally, buffer)) != 0) break;
}
else
{
if ((result = dg(buffer)) != 0) break;
}
++tally;
}
return result;
}
}
@system unittest
{
static import std.file;
scope(failure) printf("Failed test at line %d\n", __LINE__);
auto deleteme = testFilename();
scope(exit) { std.file.remove(deleteme); }
// test looping with an empty file
std.file.write(deleteme, "");
auto f = File(deleteme, "r");
foreach (ubyte[] line; chunks(f, 4))
{
assert(false);
}
f.close();
// test looping with a file with three lines
std.file.write(deleteme, "Line one\nline two\nline three\n");
f = File(deleteme, "r");
uint i = 0;
foreach (ubyte[] line; chunks(f, 3))
{
if (i == 0) assert(cast(char[]) line == "Lin");
else if (i == 1) assert(cast(char[]) line == "e o");
else if (i == 2) assert(cast(char[]) line == "ne\n");
else break;
++i;
}
f.close();
}
/**
Writes an array or range to a file.
Shorthand for $(D data.copy(File(fileName, "wb").lockingBinaryWriter)).
Similar to $(REF write, std,file), strings are written as-is,
rather than encoded according to the $(D File)'s $(HTTP
en.cppreference.com/w/c/io#Narrow_and_wide_orientation,
orientation).
*/
void toFile(T)(T data, string fileName)
if (is(typeof(copy(data, stdout.lockingBinaryWriter))))
{
copy(data, File(fileName, "wb").lockingBinaryWriter);
}
@system unittest
{
static import std.file;
auto deleteme = testFilename();
scope(exit) { std.file.remove(deleteme); }
"Test".toFile(deleteme);
assert(std.file.readText(deleteme) == "Test");
}
/*********************
* Thrown if I/O errors happen.
*/
class StdioException : Exception
{
static import core.stdc.errno;
/// Operating system error code.
uint errno;
/**
Initialize with a message and an error code.
*/
this(string message, uint e = core.stdc.errno.errno) @trusted
{
import std.exception : errnoString;
errno = e;
auto sysmsg = errnoString(errno);
// If e is 0, we don't use the system error message. (The message
// is "Success", which is rather pointless for an exception.)
super(e == 0 ? message
: (message ? message ~ " (" ~ sysmsg ~ ")" : sysmsg));
}
/** Convenience functions that throw an $(D StdioException). */
static void opCall(string msg)
{
throw new StdioException(msg);
}
/// ditto
static void opCall()
{
throw new StdioException(null, core.stdc.errno.errno);
}
}
enum StdFileHandle: string
{
stdin = "core.stdc.stdio.stdin",
stdout = "core.stdc.stdio.stdout",
stderr = "core.stdc.stdio.stderr",
}
// Undocumented but public because the std* handles are aliasing it.
@property ref File makeGlobal(StdFileHandle _iob)()
{
__gshared File.Impl impl;
__gshared File result;
// Use an inline spinlock to make sure the initializer is only run once.
// We assume there will be at most uint.max / 2 threads trying to initialize
// `handle` at once and steal the high bit to indicate that the globals have
// been initialized.
static shared uint spinlock;
import core.atomic : atomicLoad, atomicOp, MemoryOrder;
if (atomicLoad!(MemoryOrder.acq)(spinlock) <= uint.max / 2)
{
for (;;)
{
if (atomicLoad!(MemoryOrder.acq)(spinlock) > uint.max / 2)
break;
if (atomicOp!"+="(spinlock, 1) == 1)
{
with (StdFileHandle)
assert(_iob == stdin || _iob == stdout || _iob == stderr);
impl.handle = mixin(_iob);
result._p = &impl;
atomicOp!"+="(spinlock, uint.max / 2);
break;
}
atomicOp!"-="(spinlock, 1);
}
}
return result;
}
/** The standard input stream.
Bugs:
Due to $(LINK2 https://issues.dlang.org/show_bug.cgi?id=15768, bug 15768),
it is thread un-safe to reassign `stdin` to a different `File` instance
than the default.
Returns: stdin as a $(LREF File).
*/
alias stdin = makeGlobal!(StdFileHandle.stdin);
///
@safe unittest
{
// Read stdin, sort lines, write to stdout
import std.algorithm.mutation : copy;
import std.algorithm.sorting : sort;
import std.array : array;
import std.typecons : Yes;
void main()
{
stdin // read from stdin
.byLineCopy(Yes.keepTerminator) // copying each line
.array() // convert to array of lines
.sort() // sort the lines
.copy( // copy output of .sort to an OutputRange
stdout.lockingTextWriter()); // the OutputRange
}
}
/**
The standard output stream.
Bugs:
Due to $(LINK2 https://issues.dlang.org/show_bug.cgi?id=15768, bug 15768),
it is thread un-safe to reassign `stdout` to a different `File` instance
than the default.
Returns: stdout as a $(LREF File).
*/
alias stdout = makeGlobal!(StdFileHandle.stdout);
///
@safe unittest
{
void main()
{
stdout.writeln("Write a message to stdout.");
}
}
///
@safe unittest
{
void main()
{
import std.algorithm.iteration : filter, map, sum;
import std.format : format;
import std.range : iota, tee;
int len;
const r = 6.iota
.filter!(a => a % 2) // 1 3 5
.map!(a => a * 2) // 2 6 10
.tee!(_ => stdout.writefln("len: %d", len++))
.sum;
assert(r == 18);
}
}
///
@safe unittest
{
void main()
{
import std.algorithm.mutation : copy;
import std.algorithm.iteration : map;
import std.format : format;
import std.range : iota;
10.iota
.map!(e => "N: %d".format(e))
.copy(stdout.lockingTextWriter()); // the OutputRange
}
}
/**
The standard error stream.
Bugs:
Due to $(LINK2 https://issues.dlang.org/show_bug.cgi?id=15768, bug 15768),
it is thread un-safe to reassign `stderr` to a different `File` instance
than the default.
Returns: stderr as a $(LREF File).
*/
alias stderr = makeGlobal!(StdFileHandle.stderr);
///
@safe unittest
{
void main()
{
stderr.writeln("Write a message to stderr.");
}
}
@system unittest
{
static import std.file;
import std.typecons : tuple;
scope(failure) printf("Failed test at line %d\n", __LINE__);
auto deleteme = testFilename();
std.file.write(deleteme, "1 2\n4 1\n5 100");
scope(exit) std.file.remove(deleteme);
{
File f = File(deleteme);
scope(exit) f.close();
auto t = [ tuple(1, 2), tuple(4, 1), tuple(5, 100) ];
uint i;
foreach (e; f.byRecord!(int, int)("%s %s"))
{
//writeln(e);
assert(e == t[i++]);
}
assert(i == 3);
}
}
@safe unittest
{
// Retain backwards compatibility
// https://issues.dlang.org/show_bug.cgi?id=17472
static assert(is(typeof(stdin) == File));
static assert(is(typeof(stdout) == File));
static assert(is(typeof(stderr) == File));
}
// roll our own appender, but with "safe" arrays
private struct ReadlnAppender
{
char[] buf;
size_t pos;
bool safeAppend = false;
void initialize(char[] b)
{
buf = b;
pos = 0;
}
@property char[] data() @trusted
{
if (safeAppend)
assumeSafeAppend(buf.ptr[0 .. pos]);
return buf.ptr[0 .. pos];
}
bool reserveWithoutAllocating(size_t n)
{
if (buf.length >= pos + n) // buf is already large enough
return true;
immutable curCap = buf.capacity;
if (curCap >= pos + n)
{
buf.length = curCap;
/* Any extra capacity we end up not using can safely be claimed
by someone else. */
safeAppend = true;
return true;
}
return false;
}
void reserve(size_t n) @trusted
{
import core.stdc.string : memcpy;
if (!reserveWithoutAllocating(n))
{
size_t ncap = buf.length * 2 + 128 + n;
char[] nbuf = new char[ncap];
memcpy(nbuf.ptr, buf.ptr, pos);
buf = nbuf;
// Allocated a new buffer. No one else knows about it.
safeAppend = true;
}
}
void putchar(char c) @trusted
{
reserve(1);
buf.ptr[pos++] = c;
}
void putdchar(dchar dc) @trusted
{
import std.utf : encode, UseReplacementDchar;
char[4] ubuf;
immutable size = encode!(UseReplacementDchar.yes)(ubuf, dc);
reserve(size);
foreach (c; ubuf)
buf.ptr[pos++] = c;
}
void putonly(char[] b) @trusted
{
import core.stdc.string : memcpy;
assert(pos == 0); // assume this is the only put call
if (reserveWithoutAllocating(b.length))
memcpy(buf.ptr + pos, b.ptr, b.length);
else
buf = b.dup;
pos = b.length;
}
}
// Private implementation of readln
version (DIGITAL_MARS_STDIO)
private size_t readlnImpl(FILE* fps, ref char[] buf, dchar terminator, File.Orientation /*ignored*/)
{
FLOCK(fps);
scope(exit) FUNLOCK(fps);
/* Since fps is now locked, we can create an "unshared" version
* of fp.
*/
auto fp = cast(_iobuf*) fps;
ReadlnAppender app;
app.initialize(buf);
if (__fhnd_info[fp._file] & FHND_WCHAR)
{ /* Stream is in wide characters.
* Read them and convert to chars.
*/
static assert(wchar_t.sizeof == 2);
for (int c = void; (c = FGETWC(fp)) != -1; )
{
if ((c & ~0x7F) == 0)
{
app.putchar(cast(char) c);
if (c == terminator)
break;
}
else
{
if (c >= 0xD800 && c <= 0xDBFF)
{
int c2 = void;
if ((c2 = FGETWC(fp)) != -1 ||
c2 < 0xDC00 && c2 > 0xDFFF)
{
StdioException("unpaired UTF-16 surrogate");
}
c = ((c - 0xD7C0) << 10) + (c2 - 0xDC00);
}
app.putdchar(cast(dchar) c);
}
}
if (ferror(fps))
StdioException();
}
else if (fp._flag & _IONBF)
{
/* Use this for unbuffered I/O, when running
* across buffer boundaries, or for any but the common
* cases.
*/
L1:
int c;
while ((c = FGETC(fp)) != -1)
{
app.putchar(cast(char) c);
if (c == terminator)
{
buf = app.data;
return buf.length;
}
}
if (ferror(fps))
StdioException();
}
else
{
int u = fp._cnt;
char* p = fp._ptr;
int i;
if (fp._flag & _IOTRAN)
{ /* Translated mode ignores \r and treats ^Z as end-of-file
*/
char c;
while (1)
{
if (i == u) // if end of buffer
goto L1; // give up
c = p[i];
i++;
if (c != '\r')
{
if (c == terminator)
break;
if (c != 0x1A)
continue;
goto L1;
}
else
{ if (i != u && p[i] == terminator)
break;
goto L1;
}
}
app.putonly(p[0 .. i]);
app.buf[i - 1] = cast(char) terminator;
if (terminator == '\n' && c == '\r')
i++;
}
else
{
while (1)
{
if (i == u) // if end of buffer
goto L1; // give up
auto c = p[i];
i++;
if (c == terminator)
break;
}
app.putonly(p[0 .. i]);
}
fp._cnt -= i;
fp._ptr += i;
}
buf = app.data;
return buf.length;
}
version (MICROSOFT_STDIO)
private size_t readlnImpl(FILE* fps, ref char[] buf, dchar terminator, File.Orientation /*ignored*/)
{
FLOCK(fps);
scope(exit) FUNLOCK(fps);
/* Since fps is now locked, we can create an "unshared" version
* of fp.
*/
auto fp = cast(_iobuf*) fps;
ReadlnAppender app;
app.initialize(buf);
int c;
while ((c = FGETC(fp)) != -1)
{
app.putchar(cast(char) c);
if (c == terminator)
{
buf = app.data;
return buf.length;
}
}
if (ferror(fps))
StdioException();
buf = app.data;
return buf.length;
}
version (HAS_GETDELIM)
private size_t readlnImpl(FILE* fps, ref char[] buf, dchar terminator, File.Orientation orientation)
{
import core.stdc.stdlib : free;
import core.stdc.wchar_ : fwide;
if (orientation == File.Orientation.wide)
{
/* Stream is in wide characters.
* Read them and convert to chars.
*/
FLOCK(fps);
scope(exit) FUNLOCK(fps);
auto fp = cast(_iobuf*) fps;
version (Windows)
{
buf.length = 0;
for (int c = void; (c = FGETWC(fp)) != -1; )
{
if ((c & ~0x7F) == 0)
{ buf ~= c;
if (c == terminator)
break;
}
else
{
if (c >= 0xD800 && c <= 0xDBFF)
{
int c2 = void;
if ((c2 = FGETWC(fp)) != -1 ||
c2 < 0xDC00 && c2 > 0xDFFF)
{
StdioException("unpaired UTF-16 surrogate");
}
c = ((c - 0xD7C0) << 10) + (c2 - 0xDC00);
}
import std.utf : encode;
encode(buf, c);
}
}
if (ferror(fp))
StdioException();
return buf.length;
}
else version (Posix)
{
buf.length = 0;
for (int c; (c = FGETWC(fp)) != -1; )
{
import std.utf : encode;
if ((c & ~0x7F) == 0)
buf ~= cast(char) c;
else
encode(buf, cast(dchar) c);
if (c == terminator)
break;
}
if (ferror(fps))
StdioException();
return buf.length;
}
else
{
static assert(0);
}
}
static char *lineptr = null;
static size_t n = 0;
scope(exit)
{
if (n > 128 * 1024)
{
// Bound memory used by readln
free(lineptr);
lineptr = null;
n = 0;
}
}
auto s = getdelim(&lineptr, &n, terminator, fps);
if (s < 0)
{
if (ferror(fps))
StdioException();
buf.length = 0; // end of file
return 0;
}
if (s <= buf.length)
{
buf = buf[0 .. s];
buf[] = lineptr[0 .. s];
}
else
{
buf = lineptr[0 .. s].dup;
}
return s;
}
version (NO_GETDELIM)
private size_t readlnImpl(FILE* fps, ref char[] buf, dchar terminator, File.Orientation orientation)
{
import core.stdc.wchar_ : fwide;
FLOCK(fps);
scope(exit) FUNLOCK(fps);
auto fp = cast(_iobuf*) fps;
if (orientation == File.Orientation.wide)
{
/* Stream is in wide characters.
* Read them and convert to chars.
*/
version (Windows)
{
buf.length = 0;
for (int c; (c = FGETWC(fp)) != -1; )
{
if ((c & ~0x7F) == 0)
{ buf ~= c;
if (c == terminator)
break;
}
else
{
if (c >= 0xD800 && c <= 0xDBFF)
{
int c2 = void;
if ((c2 = FGETWC(fp)) != -1 ||
c2 < 0xDC00 && c2 > 0xDFFF)
{
StdioException("unpaired UTF-16 surrogate");
}
c = ((c - 0xD7C0) << 10) + (c2 - 0xDC00);
}
import std.utf : encode;
encode(buf, c);
}
}
if (ferror(fp))
StdioException();
return buf.length;
}
else version (Posix)
{
import std.utf : encode;
buf.length = 0;
for (int c; (c = FGETWC(fp)) != -1; )
{
if ((c & ~0x7F) == 0)
buf ~= cast(char) c;
else
encode(buf, cast(dchar) c);
if (c == terminator)
break;
}
if (ferror(fps))
StdioException();
return buf.length;
}
else
{
static assert(0);
}
}
// Narrow stream
// First, fill the existing buffer
for (size_t bufPos = 0; bufPos < buf.length; )
{
immutable c = FGETC(fp);
if (c == -1)
{
buf.length = bufPos;
goto endGame;
}
buf[bufPos++] = cast(char) c;
if (c == terminator)
{
// No need to test for errors in file
buf.length = bufPos;
return bufPos;
}
}
// Then, append to it
for (int c; (c = FGETC(fp)) != -1; )
{
buf ~= cast(char) c;
if (c == terminator)
{
// No need to test for errors in file
return buf.length;
}
}
endGame:
if (ferror(fps))
StdioException();
return buf.length;
}
@system unittest
{
static import std.file;
auto deleteme = testFilename();
scope(exit) std.file.remove(deleteme);
std.file.write(deleteme, "abcd\n0123456789abcde\n1234\n");
File f = File(deleteme, "rb");
char[] ln = new char[2];
f.readln(ln);
assert(ln == "abcd\n");
char[] t = ln[0 .. 2];
t ~= 't';
assert(t == "abt");
assert(ln == "abcd\n"); // bug 13856: ln stomped to "abtd"
// it can also stomp the array length
ln = new char[4];
f.readln(ln);
assert(ln == "0123456789abcde\n");
char[100] buf;
ln = buf[];
f.readln(ln);
assert(ln == "1234\n");
assert(ln.ptr == buf.ptr); // avoid allocation, buffer is good enough
}
/** Experimental network access via the File interface
Opens a TCP connection to the given host and port, then returns
a File struct with read and write access through the same interface
as any other file (meaning writef and the byLine ranges work!).
Authors:
Adam D. Ruppe
Bugs:
Only works on Linux
*/
version(linux)
{
File openNetwork(string host, ushort port)
{
import core.stdc.string : memcpy;
import core.sys.posix.arpa.inet : htons;
import core.sys.posix.netdb : gethostbyname;
import core.sys.posix.netinet.in_ : sockaddr_in;
static import core.sys.posix.unistd;
static import sock = core.sys.posix.sys.socket;
import std.conv : to;
import std.exception : enforce;
import std.internal.cstring : tempCString;
auto h = enforce( gethostbyname(host.tempCString()),
new StdioException("gethostbyname"));
int s = sock.socket(sock.AF_INET, sock.SOCK_STREAM, 0);
enforce(s != -1, new StdioException("socket"));
scope(failure)
{
// want to make sure it doesn't dangle if something throws. Upon
// normal exit, the File struct's reference counting takes care of
// closing, so we don't need to worry about success
core.sys.posix.unistd.close(s);
}
sockaddr_in addr;
addr.sin_family = sock.AF_INET;
addr.sin_port = htons(port);
memcpy(&addr.sin_addr.s_addr, h.h_addr, h.h_length);
enforce(sock.connect(s, cast(sock.sockaddr*) &addr, addr.sizeof) != -1,
new StdioException("Connect failed"));
File f;
f.fdopen(s, "w+", host ~ ":" ~ to!string(port));
return f;
}
}
version(unittest) string testFilename(string file = __FILE__, size_t line = __LINE__) @safe
{
import std.conv : text;
import std.file : deleteme;
import std.path : baseName;
// filename intentionally contains non-ASCII (Russian) characters for test Issue 7648
return text(deleteme, "-детка.", baseName(file), ".", line);
}
|
D
|
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 3.0.0
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
module vtkNonOverlappingAMRAlgorithm;
static import vtkd_im;
static import core.stdc.config;
static import std.conv;
static import std.string;
static import std.conv;
static import std.string;
static import vtkObjectBase;
static import vtkNonOverlappingAMR;
static import vtkUniformGridAMRAlgorithm;
class vtkNonOverlappingAMRAlgorithm : vtkUniformGridAMRAlgorithm.vtkUniformGridAMRAlgorithm {
private void* swigCPtr;
public this(void* cObject, bool ownCObject) {
super(vtkd_im.vtkNonOverlappingAMRAlgorithm_Upcast(cObject), ownCObject);
swigCPtr = cObject;
}
public static void* swigGetCPtr(vtkNonOverlappingAMRAlgorithm obj) {
return (obj is null) ? null : obj.swigCPtr;
}
mixin vtkd_im.SwigOperatorDefinitions;
public override void dispose() {
synchronized(this) {
if (swigCPtr !is null) {
if (swigCMemOwn) {
swigCMemOwn = false;
throw new object.Exception("C++ destructor does not have public access");
}
swigCPtr = null;
super.dispose();
}
}
}
public static vtkNonOverlappingAMRAlgorithm New() {
void* cPtr = vtkd_im.vtkNonOverlappingAMRAlgorithm_New();
vtkNonOverlappingAMRAlgorithm ret = (cPtr is null) ? null : new vtkNonOverlappingAMRAlgorithm(cPtr, false);
return ret;
}
public static int IsTypeOf(string type) {
auto ret = vtkd_im.vtkNonOverlappingAMRAlgorithm_IsTypeOf((type ? std.string.toStringz(type) : null));
return ret;
}
public static vtkNonOverlappingAMRAlgorithm SafeDownCast(vtkObjectBase.vtkObjectBase o) {
void* cPtr = vtkd_im.vtkNonOverlappingAMRAlgorithm_SafeDownCast(vtkObjectBase.vtkObjectBase.swigGetCPtr(o));
vtkNonOverlappingAMRAlgorithm ret = (cPtr is null) ? null : new vtkNonOverlappingAMRAlgorithm(cPtr, false);
return ret;
}
public vtkNonOverlappingAMRAlgorithm NewInstance() const {
void* cPtr = vtkd_im.vtkNonOverlappingAMRAlgorithm_NewInstance(cast(void*)swigCPtr);
vtkNonOverlappingAMRAlgorithm ret = (cPtr is null) ? null : new vtkNonOverlappingAMRAlgorithm(cPtr, false);
return ret;
}
alias vtkUniformGridAMRAlgorithm.vtkUniformGridAMRAlgorithm.NewInstance NewInstance;
public vtkNonOverlappingAMR.vtkNonOverlappingAMR GetOutput() {
void* cPtr = vtkd_im.vtkNonOverlappingAMRAlgorithm_GetOutput__SWIG_0(cast(void*)swigCPtr);
vtkNonOverlappingAMR.vtkNonOverlappingAMR ret = (cPtr is null) ? null : new vtkNonOverlappingAMR.vtkNonOverlappingAMR(cPtr, false);
return ret;
}
public vtkNonOverlappingAMR.vtkNonOverlappingAMR GetOutput(int arg0) {
void* cPtr = vtkd_im.vtkNonOverlappingAMRAlgorithm_GetOutput__SWIG_1(cast(void*)swigCPtr, arg0);
vtkNonOverlappingAMR.vtkNonOverlappingAMR ret = (cPtr is null) ? null : new vtkNonOverlappingAMR.vtkNonOverlappingAMR(cPtr, false);
return ret;
}
alias vtkUniformGridAMRAlgorithm.vtkUniformGridAMRAlgorithm.GetOutput GetOutput;
}
|
D
|
module ecoji.d.mapping;
immutable dchar PADDING = '\u2615';
immutable dchar PADDING40 = '\u269C';
immutable dchar PADDING41 = '\U0001F3CD';
immutable dchar PADDING42 = '\U0001F4D1';
immutable dchar PADDING43 = '\U0001F64B';
immutable dchar[1024] EMOJIS = [
'\U0001F004', '\U0001F0CF', '\U0001F170', '\U0001F171', '\U0001F17E',
'\U0001F17F', '\U0001F18E', '\U0001F191', '\U0001F192', '\U0001F193',
'\U0001F194', '\U0001F195', '\U0001F196', '\U0001F197', '\U0001F198',
'\U0001F199', '\U0001F19A', '\U0001F1E6', '\U0001F1E7', '\U0001F1E8',
'\U0001F1E9', '\U0001F1EA', '\U0001F1EB', '\U0001F1EC', '\U0001F1ED',
'\U0001F1EE', '\U0001F1EF', '\U0001F1F0', '\U0001F1F1', '\U0001F1F2',
'\U0001F1F3', '\U0001F1F4', '\U0001F1F5', '\U0001F1F6', '\U0001F1F7',
'\U0001F1F8', '\U0001F1F9', '\U0001F1FA', '\U0001F1FB', '\U0001F1FC',
'\U0001F1FD', '\U0001F1FE', '\U0001F1FF', '\U0001F201', '\U0001F202',
'\U0001F21A', '\U0001F22F', '\U0001F232', '\U0001F233', '\U0001F234',
'\U0001F235', '\U0001F236', '\U0001F237', '\U0001F238', '\U0001F239',
'\U0001F23A', '\U0001F250', '\U0001F251', '\U0001F300', '\U0001F301',
'\U0001F302', '\U0001F303', '\U0001F304', '\U0001F305', '\U0001F306',
'\U0001F307', '\U0001F308', '\U0001F309', '\U0001F30A', '\U0001F30B',
'\U0001F30C', '\U0001F30D', '\U0001F30E', '\U0001F30F', '\U0001F310',
'\U0001F311', '\U0001F312', '\U0001F313', '\U0001F314', '\U0001F315',
'\U0001F316', '\U0001F317', '\U0001F318', '\U0001F319', '\U0001F31A',
'\U0001F31B', '\U0001F31C', '\U0001F31D', '\U0001F31E', '\U0001F31F',
'\U0001F320', '\U0001F321', '\U0001F324', '\U0001F325', '\U0001F326',
'\U0001F327', '\U0001F328', '\U0001F329', '\U0001F32A', '\U0001F32B',
'\U0001F32C', '\U0001F32D', '\U0001F32E', '\U0001F32F', '\U0001F330',
'\U0001F331', '\U0001F332', '\U0001F333', '\U0001F334', '\U0001F335',
'\U0001F336', '\U0001F337', '\U0001F338', '\U0001F339', '\U0001F33A',
'\U0001F33B', '\U0001F33C', '\U0001F33D', '\U0001F33E', '\U0001F33F',
'\U0001F340', '\U0001F341', '\U0001F342', '\U0001F343', '\U0001F344',
'\U0001F345', '\U0001F346', '\U0001F347', '\U0001F348', '\U0001F349',
'\U0001F34A', '\U0001F34B', '\U0001F34C', '\U0001F34D', '\U0001F34E',
'\U0001F34F', '\U0001F350', '\U0001F351', '\U0001F352', '\U0001F353',
'\U0001F354', '\U0001F355', '\U0001F356', '\U0001F357', '\U0001F358',
'\U0001F359', '\U0001F35A', '\U0001F35B', '\U0001F35C', '\U0001F35D',
'\U0001F35E', '\U0001F35F', '\U0001F360', '\U0001F361', '\U0001F362',
'\U0001F363', '\U0001F364', '\U0001F365', '\U0001F366', '\U0001F367',
'\U0001F368', '\U0001F369', '\U0001F36A', '\U0001F36B', '\U0001F36C',
'\U0001F36D', '\U0001F36E', '\U0001F36F', '\U0001F370', '\U0001F371',
'\U0001F372', '\U0001F373', '\U0001F374', '\U0001F375', '\U0001F376',
'\U0001F377', '\U0001F378', '\U0001F379', '\U0001F37A', '\U0001F37B',
'\U0001F37C', '\U0001F37D', '\U0001F37E', '\U0001F37F', '\U0001F380',
'\U0001F381', '\U0001F382', '\U0001F383', '\U0001F384', '\U0001F385',
'\U0001F386', '\U0001F387', '\U0001F388', '\U0001F389', '\U0001F38A',
'\U0001F38B', '\U0001F38C', '\U0001F38D', '\U0001F38E', '\U0001F38F',
'\U0001F390', '\U0001F391', '\U0001F392', '\U0001F393', '\U0001F396',
'\U0001F397', '\U0001F399', '\U0001F39A', '\U0001F39B', '\U0001F39E',
'\U0001F39F', '\U0001F3A0', '\U0001F3A1', '\U0001F3A2', '\U0001F3A3',
'\U0001F3A4', '\U0001F3A5', '\U0001F3A6', '\U0001F3A7', '\U0001F3A8',
'\U0001F3A9', '\U0001F3AA', '\U0001F3AB', '\U0001F3AC', '\U0001F3AD',
'\U0001F3AE', '\U0001F3AF', '\U0001F3B0', '\U0001F3B1', '\U0001F3B2',
'\U0001F3B3', '\U0001F3B4', '\U0001F3B5', '\U0001F3B6', '\U0001F3B7',
'\U0001F3B8', '\U0001F3B9', '\U0001F3BA', '\U0001F3BB', '\U0001F3BC',
'\U0001F3BD', '\U0001F3BE', '\U0001F3BF', '\U0001F3C0', '\U0001F3C1',
'\U0001F3C2', '\U0001F3C3', '\U0001F3C4', '\U0001F3C5', '\U0001F3C6',
'\U0001F3C7', '\U0001F3C8', '\U0001F3C9', '\U0001F3CA', '\U0001F3CB',
'\U0001F3CC', '\U0001F3CE', '\U0001F3CF', '\U0001F3D0', '\U0001F3D1',
'\U0001F3D2', '\U0001F3D3', '\U0001F3D4', '\U0001F3D5', '\U0001F3D6',
'\U0001F3D7', '\U0001F3D8', '\U0001F3D9', '\U0001F3DA', '\U0001F3DB',
'\U0001F3DC', '\U0001F3DD', '\U0001F3DE', '\U0001F3DF', '\U0001F3E0',
'\U0001F3E1', '\U0001F3E2', '\U0001F3E3', '\U0001F3E4', '\U0001F3E5',
'\U0001F3E6', '\U0001F3E7', '\U0001F3E8', '\U0001F3E9', '\U0001F3EA',
'\U0001F3EB', '\U0001F3EC', '\U0001F3ED', '\U0001F3EE', '\U0001F3EF',
'\U0001F3F0', '\U0001F3F3', '\U0001F3F4', '\U0001F3F5', '\U0001F3F7',
'\U0001F3F8', '\U0001F3F9', '\U0001F3FA', '\U0001F3FB', '\U0001F3FC',
'\U0001F3FD', '\U0001F3FE', '\U0001F3FF', '\U0001F400', '\U0001F401',
'\U0001F402', '\U0001F403', '\U0001F404', '\U0001F405', '\U0001F406',
'\U0001F407', '\U0001F408', '\U0001F409', '\U0001F40A', '\U0001F40B',
'\U0001F40C', '\U0001F40D', '\U0001F40E', '\U0001F40F', '\U0001F410',
'\U0001F411', '\U0001F412', '\U0001F413', '\U0001F414', '\U0001F415',
'\U0001F416', '\U0001F417', '\U0001F418', '\U0001F419', '\U0001F41A',
'\U0001F41B', '\U0001F41C', '\U0001F41D', '\U0001F41E', '\U0001F41F',
'\U0001F420', '\U0001F421', '\U0001F422', '\U0001F423', '\U0001F424',
'\U0001F425', '\U0001F426', '\U0001F427', '\U0001F428', '\U0001F429',
'\U0001F42A', '\U0001F42B', '\U0001F42C', '\U0001F42D', '\U0001F42E',
'\U0001F42F', '\U0001F430', '\U0001F431', '\U0001F432', '\U0001F433',
'\U0001F434', '\U0001F435', '\U0001F436', '\U0001F437', '\U0001F438',
'\U0001F439', '\U0001F43A', '\U0001F43B', '\U0001F43C', '\U0001F43D',
'\U0001F43E', '\U0001F43F', '\U0001F440', '\U0001F441', '\U0001F442',
'\U0001F443', '\U0001F444', '\U0001F445', '\U0001F446', '\U0001F447',
'\U0001F448', '\U0001F449', '\U0001F44A', '\U0001F44B', '\U0001F44C',
'\U0001F44D', '\U0001F44E', '\U0001F44F', '\U0001F450', '\U0001F451',
'\U0001F452', '\U0001F453', '\U0001F454', '\U0001F455', '\U0001F456',
'\U0001F457', '\U0001F458', '\U0001F459', '\U0001F45A', '\U0001F45B',
'\U0001F45C', '\U0001F45D', '\U0001F45E', '\U0001F45F', '\U0001F460',
'\U0001F461', '\U0001F462', '\U0001F463', '\U0001F464', '\U0001F465',
'\U0001F466', '\U0001F467', '\U0001F468', '\U0001F469', '\U0001F46A',
'\U0001F46B', '\U0001F46C', '\U0001F46D', '\U0001F46E', '\U0001F46F',
'\U0001F470', '\U0001F471', '\U0001F472', '\U0001F473', '\U0001F474',
'\U0001F475', '\U0001F476', '\U0001F477', '\U0001F478', '\U0001F479',
'\U0001F47A', '\U0001F47B', '\U0001F47C', '\U0001F47D', '\U0001F47E',
'\U0001F47F', '\U0001F480', '\U0001F481', '\U0001F482', '\U0001F483',
'\U0001F484', '\U0001F485', '\U0001F486', '\U0001F487', '\U0001F488',
'\U0001F489', '\U0001F48A', '\U0001F48B', '\U0001F48C', '\U0001F48D',
'\U0001F48E', '\U0001F48F', '\U0001F490', '\U0001F491', '\U0001F492',
'\U0001F493', '\U0001F494', '\U0001F495', '\U0001F496', '\U0001F497',
'\U0001F498', '\U0001F499', '\U0001F49A', '\U0001F49B', '\U0001F49C',
'\U0001F49D', '\U0001F49E', '\U0001F49F', '\U0001F4A0', '\U0001F4A1',
'\U0001F4A2', '\U0001F4A3', '\U0001F4A4', '\U0001F4A5', '\U0001F4A6',
'\U0001F4A7', '\U0001F4A8', '\U0001F4A9', '\U0001F4AA', '\U0001F4AB',
'\U0001F4AC', '\U0001F4AD', '\U0001F4AE', '\U0001F4AF', '\U0001F4B0',
'\U0001F4B1', '\U0001F4B2', '\U0001F4B3', '\U0001F4B4', '\U0001F4B5',
'\U0001F4B6', '\U0001F4B7', '\U0001F4B8', '\U0001F4B9', '\U0001F4BA',
'\U0001F4BB', '\U0001F4BC', '\U0001F4BD', '\U0001F4BE', '\U0001F4BF',
'\U0001F4C0', '\U0001F4C1', '\U0001F4C2', '\U0001F4C3', '\U0001F4C4',
'\U0001F4C5', '\U0001F4C6', '\U0001F4C7', '\U0001F4C8', '\U0001F4C9',
'\U0001F4CA', '\U0001F4CB', '\U0001F4CC', '\U0001F4CD', '\U0001F4CE',
'\U0001F4CF', '\U0001F4D0', '\U0001F4D2', '\U0001F4D3', '\U0001F4D4',
'\U0001F4D5', '\U0001F4D6', '\U0001F4D7', '\U0001F4D8', '\U0001F4D9',
'\U0001F4DA', '\U0001F4DB', '\U0001F4DC', '\U0001F4DD', '\U0001F4DE',
'\U0001F4DF', '\U0001F4E0', '\U0001F4E1', '\U0001F4E2', '\U0001F4E3',
'\U0001F4E4', '\U0001F4E5', '\U0001F4E6', '\U0001F4E7', '\U0001F4E8',
'\U0001F4E9', '\U0001F4EA', '\U0001F4EB', '\U0001F4EC', '\U0001F4ED',
'\U0001F4EE', '\U0001F4EF', '\U0001F4F0', '\U0001F4F1', '\U0001F4F2',
'\U0001F4F3', '\U0001F4F4', '\U0001F4F5', '\U0001F4F6', '\U0001F4F7',
'\U0001F4F8', '\U0001F4F9', '\U0001F4FA', '\U0001F4FB', '\U0001F4FC',
'\U0001F4FD', '\U0001F4FF', '\U0001F500', '\U0001F501', '\U0001F502',
'\U0001F503', '\U0001F504', '\U0001F505', '\U0001F506', '\U0001F507',
'\U0001F508', '\U0001F509', '\U0001F50A', '\U0001F50B', '\U0001F50C',
'\U0001F50D', '\U0001F50E', '\U0001F50F', '\U0001F510', '\U0001F511',
'\U0001F512', '\U0001F513', '\U0001F514', '\U0001F515', '\U0001F516',
'\U0001F517', '\U0001F518', '\U0001F519', '\U0001F51A', '\U0001F51B',
'\U0001F51C', '\U0001F51D', '\U0001F51E', '\U0001F51F', '\U0001F520',
'\U0001F521', '\U0001F522', '\U0001F523', '\U0001F524', '\U0001F525',
'\U0001F526', '\U0001F527', '\U0001F528', '\U0001F529', '\U0001F52A',
'\U0001F52B', '\U0001F52C', '\U0001F52D', '\U0001F52E', '\U0001F52F',
'\U0001F530', '\U0001F531', '\U0001F532', '\U0001F533', '\U0001F534',
'\U0001F535', '\U0001F536', '\U0001F537', '\U0001F538', '\U0001F539',
'\U0001F53A', '\U0001F53B', '\U0001F53C', '\U0001F53D', '\U0001F549',
'\U0001F54A', '\U0001F54B', '\U0001F54C', '\U0001F54D', '\U0001F54E',
'\U0001F550', '\U0001F551', '\U0001F552', '\U0001F553', '\U0001F554',
'\U0001F555', '\U0001F556', '\U0001F557', '\U0001F558', '\U0001F559',
'\U0001F55A', '\U0001F55B', '\U0001F55C', '\U0001F55D', '\U0001F55E',
'\U0001F55F', '\U0001F560', '\U0001F561', '\U0001F562', '\U0001F563',
'\U0001F564', '\U0001F565', '\U0001F566', '\U0001F567', '\U0001F56F',
'\U0001F570', '\U0001F573', '\U0001F574', '\U0001F575', '\U0001F576',
'\U0001F577', '\U0001F578', '\U0001F579', '\U0001F57A', '\U0001F587',
'\U0001F58A', '\U0001F58B', '\U0001F58C', '\U0001F58D', '\U0001F590',
'\U0001F595', '\U0001F596', '\U0001F5A4', '\U0001F5A5', '\U0001F5A8',
'\U0001F5B1', '\U0001F5B2', '\U0001F5BC', '\U0001F5C2', '\U0001F5C3',
'\U0001F5C4', '\U0001F5D1', '\U0001F5D2', '\U0001F5D3', '\U0001F5DC',
'\U0001F5DD', '\U0001F5DE', '\U0001F5E1', '\U0001F5E3', '\U0001F5E8',
'\U0001F5EF', '\U0001F5F3', '\U0001F5FA', '\U0001F5FB', '\U0001F5FC',
'\U0001F5FD', '\U0001F5FE', '\U0001F5FF', '\U0001F600', '\U0001F601',
'\U0001F602', '\U0001F603', '\U0001F604', '\U0001F605', '\U0001F606',
'\U0001F607', '\U0001F608', '\U0001F609', '\U0001F60A', '\U0001F60B',
'\U0001F60C', '\U0001F60D', '\U0001F60E', '\U0001F60F', '\U0001F610',
'\U0001F611', '\U0001F612', '\U0001F613', '\U0001F614', '\U0001F615',
'\U0001F616', '\U0001F617', '\U0001F618', '\U0001F619', '\U0001F61A',
'\U0001F61B', '\U0001F61C', '\U0001F61D', '\U0001F61E', '\U0001F61F',
'\U0001F620', '\U0001F621', '\U0001F622', '\U0001F623', '\U0001F624',
'\U0001F625', '\U0001F626', '\U0001F627', '\U0001F628', '\U0001F629',
'\U0001F62A', '\U0001F62B', '\U0001F62C', '\U0001F62D', '\U0001F62E',
'\U0001F62F', '\U0001F630', '\U0001F631', '\U0001F632', '\U0001F633',
'\U0001F634', '\U0001F635', '\U0001F636', '\U0001F637', '\U0001F638',
'\U0001F639', '\U0001F63A', '\U0001F63B', '\U0001F63C', '\U0001F63D',
'\U0001F63E', '\U0001F63F', '\U0001F640', '\U0001F641', '\U0001F642',
'\U0001F643', '\U0001F644', '\U0001F645', '\U0001F646', '\U0001F647',
'\U0001F648', '\U0001F649', '\U0001F64A', '\U0001F64C', '\U0001F64D',
'\U0001F64E', '\U0001F64F', '\U0001F680', '\U0001F681', '\U0001F682',
'\U0001F683', '\U0001F684', '\U0001F685', '\U0001F686', '\U0001F687',
'\U0001F688', '\U0001F689', '\U0001F68A', '\U0001F68B', '\U0001F68C',
'\U0001F68D', '\U0001F68E', '\U0001F68F', '\U0001F690', '\U0001F691',
'\U0001F692', '\U0001F693', '\U0001F694', '\U0001F695', '\U0001F696',
'\U0001F697', '\U0001F698', '\U0001F699', '\U0001F69A', '\U0001F69B',
'\U0001F69C', '\U0001F69D', '\U0001F69E', '\U0001F69F', '\U0001F6A0',
'\U0001F6A1', '\U0001F6A2', '\U0001F6A3', '\U0001F6A4', '\U0001F6A5',
'\U0001F6A6', '\U0001F6A7', '\U0001F6A8', '\U0001F6A9', '\U0001F6AA',
'\U0001F6AB', '\U0001F6AC', '\U0001F6AD', '\U0001F6AE', '\U0001F6AF',
'\U0001F6B0', '\U0001F6B1', '\U0001F6B2', '\U0001F6B3', '\U0001F6B4',
'\U0001F6B5', '\U0001F6B6', '\U0001F6B7', '\U0001F6B8', '\U0001F6B9',
'\U0001F6BA', '\U0001F6BB', '\U0001F6BC', '\U0001F6BD', '\U0001F6BE',
'\U0001F6BF', '\U0001F6C0', '\U0001F6C1', '\U0001F6C2', '\U0001F6C3',
'\U0001F6C4', '\U0001F6C5', '\U0001F6CB', '\U0001F6CC', '\U0001F6CD',
'\U0001F6CE', '\U0001F6CF', '\U0001F6D0', '\U0001F6D1', '\U0001F6D2',
'\U0001F6E0', '\U0001F6E1', '\U0001F6E2', '\U0001F6E3', '\U0001F6E4',
'\U0001F6E5', '\U0001F6E9', '\U0001F6EB', '\U0001F6EC', '\U0001F6F0',
'\U0001F6F3', '\U0001F6F4', '\U0001F6F5', '\U0001F6F6', '\U0001F6F7',
'\U0001F6F8', '\U0001F6F9', '\U0001F910', '\U0001F911', '\U0001F912',
'\U0001F913', '\U0001F914', '\U0001F915', '\U0001F916', '\U0001F917',
'\U0001F918', '\U0001F919', '\U0001F91A', '\U0001F91B', '\U0001F91C',
'\U0001F91D', '\U0001F91E', '\U0001F91F', '\U0001F920', '\U0001F921',
'\U0001F922', '\U0001F923', '\U0001F924', '\U0001F925', '\U0001F926',
'\U0001F927', '\U0001F928', '\U0001F929', '\U0001F92A', '\U0001F92B',
'\U0001F92C', '\U0001F92D', '\U0001F92E', '\U0001F92F', '\U0001F930',
'\U0001F931', '\U0001F932', '\U0001F933', '\U0001F934', '\U0001F935',
'\U0001F936', '\U0001F937', '\U0001F938', '\U0001F939', '\U0001F93A',
'\U0001F93C', '\U0001F93D', '\U0001F93E', '\U0001F940', '\U0001F941',
'\U0001F942', '\U0001F943', '\U0001F944', '\U0001F945', '\U0001F947',
'\U0001F948', '\U0001F949', '\U0001F94A', '\U0001F94B', '\U0001F94C',
'\U0001F94D', '\U0001F94E', '\U0001F94F', '\U0001F950', '\U0001F951',
'\U0001F952', '\U0001F953', '\U0001F954', '\U0001F955', '\U0001F956',
'\U0001F957', '\U0001F958', '\U0001F959', '\U0001F95A', '\U0001F95B',
'\U0001F95C', '\U0001F95D', '\U0001F95E', '\U0001F95F', '\U0001F960',
'\U0001F961', '\U0001F962', '\U0001F963', '\U0001F964', '\U0001F965',
'\U0001F966', '\U0001F967', '\U0001F968', '\U0001F969', '\U0001F96A',
'\U0001F96B', '\U0001F96C', '\U0001F96D', '\U0001F96E', '\U0001F96F',
'\U0001F970', '\U0001F973', '\U0001F974', '\U0001F975', '\U0001F976',
'\U0001F97A', '\U0001F97C', '\U0001F97D', '\U0001F97E', '\U0001F97F',
'\U0001F980', '\U0001F981', '\U0001F982', '\U0001F983', '\U0001F984',
'\U0001F985', '\U0001F986', '\U0001F987', '\U0001F988', '\U0001F989',
'\U0001F98A', '\U0001F98B', '\U0001F98C', '\U0001F98D', '\U0001F98E',
'\U0001F98F', '\U0001F990', '\U0001F991', '\U0001F992', '\U0001F993',
'\U0001F994', '\U0001F995', '\U0001F996', '\U0001F997', '\U0001F998',
'\U0001F999', '\U0001F99A', '\U0001F99B', '\U0001F99C', '\U0001F99D',
'\U0001F99E', '\U0001F99F', '\U0001F9A0', '\U0001F9A1', '\U0001F9A2',
'\U0001F9B0', '\U0001F9B1', '\U0001F9B2', '\U0001F9B3', '\U0001F9B4',
'\U0001F9B5', '\U0001F9B6', '\U0001F9B7', '\U0001F9B8', '\U0001F9B9',
'\U0001F9C0', '\U0001F9C1', '\U0001F9C2', '\U0001F9D0', '\U0001F9D1',
'\U0001F9D2', '\U0001F9D3', '\U0001F9D4', '\U0001F9D5',
];
|
D
|
/home/jcawl/code/learn_rust/crates_programs/cli_graph_crate/target/debug/deps/cli_graph_crate-a49a54ac109665ae.rmeta: src/main.rs
/home/jcawl/code/learn_rust/crates_programs/cli_graph_crate/target/debug/deps/cli_graph_crate-a49a54ac109665ae.d: src/main.rs
src/main.rs:
|
D
|
module more.parse;
// returns: ubyte.max on error
ubyte hexValue(char c)
{
if(c <= '9') {
return (c >= '0') ? cast(ubyte)(c - '0') : ubyte.max;
}
if(c >= 'a') {
return (c <= 'f') ? cast(ubyte)(c + 10 - 'a') : ubyte.max;
}
if(c >= 'A' && c <= 'F') {
return cast(ubyte)(c + 10 - 'A');
}
return ubyte.max;
}
unittest
{
assert(ubyte.max == hexValue('/'));
assert(0 == hexValue('0'));
assert(9 == hexValue('9'));
assert(ubyte.max == hexValue(':'));
assert(ubyte.max == hexValue('@'));
assert(10 == hexValue('A'));
assert(15 == hexValue('F'));
assert(ubyte.max == hexValue('G'));
assert(ubyte.max == hexValue('`'));
assert(10 == hexValue('a'));
assert(15 == hexValue('f'));
assert(ubyte.max == hexValue('g'));
for(int cAsInt = char.min; cAsInt <= char.max; cAsInt++) {
char c = cast(char)cAsInt;
if(c >= '0' && c <= '9') {
assert(c - '0' == hexValue(c));
} else if(c >= 'a' && c <= 'f') {
assert(c + 10 - 'a' == hexValue(c));
} else if(c >= 'A' && c <= 'F') {
assert(c + 10 - 'A' == hexValue(c));
} else {
assert(ubyte.max == hexValue(c));
}
}
}
bool hasCharSet(string charSet)(const(char)* str, const(char)* limit)
{
for(;; str++)
{
if (str >= limit)
return false;
auto c = *str;
foreach(charSetChar; charSet) {
if(c == charSetChar) {
return true;
}
}
}
}
pragma(inline)
bool hasCharSet(string charSet)(const(char)[] str)
{
return hasCharSet!charSet(str.ptr, str.ptr + str.length);
}
/**
Iterates over the given string and returns a pointer to the first character that
is not in the given $(D charSet).
*/
inout(char)* skipCharSet(string charSet)(inout(char)* str)
{
STR_LOOP:
for(;;)
{
auto c = *str;
foreach(charSetChar; charSet) {
if(c == charSetChar) {
str++;
continue STR_LOOP;
}
}
break;
}
return str;
}
/// ditto
inout(char)* skipCharSet(string charSet)(inout(char)* str, const(char)* limit)
{
STR_LOOP:
for(;str < limit;)
{
auto c = *str;
foreach(charSetChar; charSet) {
if(c == charSetChar) {
str++;
continue STR_LOOP;
}
}
break;
}
return str;
}
/**
Iterates over the given string and returns a pointer to the first character that
is not a space.
*/
pragma(inline) inout(char)* skipSpace(inout(char)* str)
{
return skipCharSet!" "(str);
}
pragma(inline) inout(char)* skipSpace(inout(char)* str, const(char)* limit)
{
return skipCharSet!" "(str, limit);
}
// TODO: create more overloads
bool startsWith(const(char)* str, const(char)* limit, const(char)[] needle)
{
auto size = limit - str;
if(size < needle.length)
{
return false;
}
return str[0..needle.length] == needle[];
}
/** Returns a pointer to the first occurence of $(D c) or $(D sentinal).
*/
inout(char)* findCharPtr(char sentinal = '\0')(inout(char)* str, char c)
{
for(;;str++) {
if(*str == c || *str == sentinal) {
return str;
}
}
}
/** Returns a pointer to the first occurence of $(D c). If no $(D c) is found
then the limit is returned.
*/
inout(char)* findCharPtr(inout(char)* str, const(char)* limit, char c)
{
for(;;str++) {
if(str >= limit || *str == c) {
return str;
}
}
}
/// ditto
pragma(inline)
inout(char)* findCharPtr(inout(char)[] str, char c)
{
return findCharPtr(str.ptr, str.ptr + str.length, c);
}
/** Returns the index of the first occurence of $(D c). If no $(D c) is found
then the length of the string is returned.
*/
size_t findCharIndex(char sentinal = '\0')(const(char)* str, char c)
{
auto saveStart = str;
for(;;str++) {
if(*str == c || *str == sentinal) {
return str - saveStart;
}
}
}
size_t findCharIndex(const(char)* str, const(char)* limit, char c)
{
auto saveStart = str;
for(;;str++) {
if(str >= limit || *str == c) {
return str - saveStart;
}
}
}
size_t findCharIndex(const(char)[] str, char c)
{
foreach(i, strChar; str) {
if(c == strChar) {
return i;
}
}
return str.length;
}
|
D
|
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int h, w, k;
rd(h, w, k);
const int mod = 10 ^^ 9 + 7;
auto dp = new int[](w);
dp[0] = 1;
foreach (_; 0 .. h) {
auto nex = new int[](w);
foreach (bit; 0 .. (1 << (w - 1))) {
if (bit & (bit >> 1))
continue;
foreach (i; 0 .. w) {
if (i - 1 >= 0 && bit & (1 << (i - 1))) {
(nex[i - 1] += dp[i]) %= mod;
} else if (i < w - 1 && bit & (1 << i)) {
(nex[i + 1] += dp[i]) %= mod;
} else {
(nex[i] += dp[i]) %= mod;
}
}
}
dp.swap(nex);
}
writeln(dp[k - 1]);
}
void rd(T...)(ref T x) {
import std.stdio : readln;
import std.string : split;
import std.conv : to;
auto l = readln.split;
assert(l.length == x.length);
foreach (i, ref e; x)
e = l[i].to!(typeof(e));
}
|
D
|
import imports.fail356;
int imports; // collides with package name
|
D
|
instance DIA_Addon_Esteban_EXIT(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 999;
condition = DIA_Addon_Esteban_EXIT_Condition;
information = DIA_Addon_Esteban_EXIT_Info;
permanent = TRUE;
description = Dialog_Ende;
};
func int DIA_Addon_Esteban_EXIT_Condition()
{
if(Bodyguard_Killer == FALSE)
{
return TRUE;
};
};
func void DIA_Addon_Esteban_EXIT_Info()
{
AI_StopProcessInfos(self);
};
instance DIA_Addon_Esteban_PICKPOCKET(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 900;
condition = DIA_Addon_Esteban_PICKPOCKET_Condition;
information = DIA_Addon_Esteban_PICKPOCKET_Info;
permanent = TRUE;
description = Pickpocket_120;
};
func int DIA_Addon_Esteban_PICKPOCKET_Condition()
{
return C_Beklauen(105,500);
};
func void DIA_Addon_Esteban_PICKPOCKET_Info()
{
Info_ClearChoices(DIA_Addon_Esteban_PICKPOCKET);
Info_AddChoice(DIA_Addon_Esteban_PICKPOCKET,Dialog_Back,DIA_Addon_Esteban_PICKPOCKET_BACK);
Info_AddChoice(DIA_Addon_Esteban_PICKPOCKET,DIALOG_PICKPOCKET,DIA_Addon_Esteban_PICKPOCKET_DoIt);
};
func void DIA_Addon_Esteban_PICKPOCKET_DoIt()
{
B_Beklauen();
Info_ClearChoices(DIA_Addon_Esteban_PICKPOCKET);
};
func void DIA_Addon_Esteban_PICKPOCKET_BACK()
{
Info_ClearChoices(DIA_Addon_Esteban_PICKPOCKET);
};
instance DIA_Addon_Esteban_Hi(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 2;
condition = DIA_Addon_Esteban_Hi_Condition;
information = DIA_Addon_Esteban_Hi_Info;
permanent = FALSE;
important = TRUE;
};
func int DIA_Addon_Esteban_Hi_Condition()
{
if(Npc_IsInState(self,ZS_Talk) && (self.aivar[AIV_TalkedToPlayer] == FALSE))
{
return TRUE;
};
};
func void DIA_Addon_Esteban_Hi_Info()
{
AI_Output(self,other,"DIA_Addon_Esteban_Hi_07_00"); //Так ты тот самый парень, что с боем пробился в лагерь.
AI_Output(other,self,"DIA_Addon_Esteban_Hi_15_01"); //Слухи быстро распространяются...
if(Npc_IsDead(Franco))
{
AI_Output(self,other,"DIA_Addon_Esteban_Hi_07_02"); //Франко был крепким орешком. Никто не хотел связываться с ним. Никто - кроме тебя.
}
else
{
B_StartOtherRoutine(Carlos,"GUARD");
};
AI_Output(self,other,"DIA_Addon_Esteban_Hi_07_03"); //Просто чтобы сразу прояснить ситуацию - если ты затеешь то же со мной, я убью тебя.
EnteredBanditsCamp = TRUE;
};
instance DIA_Addon_Esteban_Mine(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 3;
condition = DIA_Addon_Esteban_Mine_Condition;
information = DIA_Addon_Esteban_Mine_Info;
permanent = FALSE;
description = "Я хочу попасть в шахту!";
};
func int DIA_Addon_Esteban_Mine_Condition()
{
if(Npc_KnowsInfo(other,DIA_Addon_Esteban_Hi))
{
return TRUE;
};
};
func void DIA_Addon_Esteban_Mine_Info()
{
AI_Output(other,self,"DIA_Addon_Esteban_Mine_15_00"); //Я хочу попасть в шахту!
AI_Output(self,other,"DIA_Addon_Esteban_Mine_07_01"); //(ухмыляясь) Естественно. Тогда ты пришел в правильное место к правильному человеку.
AI_Output(self,other,"DIA_Addon_Esteban_Mine_07_02"); //Потому что каждый, кто копает в шахте, оставляет себе изрядную долю золота.
AI_Output(self,other,"DIA_Addon_Esteban_Mine_07_03"); //А я выдаю красные камни, один из которых тебе будет нужен, чтобы Торус впустил тебя.
};
instance DIA_Addon_Esteban_Rot(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 3;
condition = DIA_Addon_Esteban_Rot_Condition;
information = DIA_Addon_Esteban_Rot_Info;
permanent = FALSE;
description = "Дай мне один из этих красных камней.";
};
func int DIA_Addon_Esteban_Rot_Condition()
{
if(Npc_KnowsInfo(other,DIA_Addon_Esteban_Mine))
{
return TRUE;
};
};
func void DIA_Addon_Esteban_Rot_Info()
{
AI_Output(other,self,"DIA_Addon_Esteban_Rot_15_00"); //Дай мне один из этих красных камней.
AI_Output(self,other,"DIA_Addon_Esteban_Rot_07_01"); //Хорошо, но это не бесплатно.
AI_Output(self,other,"DIA_Addon_Esteban_Rot_07_02"); //Обычно я прошу часть того золота, что рудокоп получает за работу.
AI_Output(self,other,"DIA_Addon_Esteban_Rot_07_03"); //(оценивающе) Много ли ты знаешь о том, как добывать золото?
if(Hero_HackChance > 25)
{
AI_Output(self,other,"DIA_Addon_Esteban_Rot_07_04"); //Ты, наверное, наработал несколько приемов, верно?
}
else
{
AI_Output(self,other,"DIA_Addon_Esteban_Rot_07_05"); //Кажется, ты об этом ничего не знаешь.
};
AI_Output(self,other,"DIA_Addon_Esteban_Rot_07_06"); //(фальшиво) Если я и дам тебе красный камень, то не потому, что ты такой хороший рудокоп.
AI_Output(self,other,"DIA_Addon_Esteban_Rot_07_07"); //Нет, у меня есть для тебя другая работа...
};
instance DIA_Addon_Esteban_MIS(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 4;
condition = DIA_Addon_Esteban_MIS_Condition;
information = DIA_Addon_Esteban_MIS_Info;
permanent = FALSE;
description = "Какая работа?";
};
func int DIA_Addon_Esteban_MIS_Condition()
{
if(Npc_KnowsInfo(other,DIA_Addon_Esteban_Rot))
{
return TRUE;
};
};
func void DIA_Addon_Esteban_MIS_Info()
{
AI_Output(other,self,"DIA_Addon_Esteban_MIS_15_00"); //Какая работа?
AI_Output(self,other,"DIA_Addon_Esteban_MIS_07_01"); //Один из бандитов хотел меня убить. Но вместо этого мои охранники убили ЕГО.
AI_Output(other,self,"DIA_Addon_Esteban_MIS_15_02"); //Он хотел занять твое место?
AI_Output(self,other,"DIA_Addon_Esteban_MIS_07_03"); //Он был просто дурень! Безмозглый убийца. Самому ему бы никогда в голову не пришло напасть на меня.
AI_Output(self,other,"DIA_Addon_Esteban_MIS_07_04"); //Он выполнял чье-то задание - кто-то послал его сделать это...
AI_Output(other,self,"DIA_Addon_Esteban_MIS_15_05"); //Так что же, мне нужно найти того, кто стоит за всем этим?
AI_Output(self,other,"DIA_Addon_Esteban_MIS_07_06"); //Тот, кто послал убийцу, заплатит за это. Найди его - и я дам тебе пропуск в шахту.
if(!Npc_IsDead(Senyan) && Npc_KnowsInfo(other,DIA_Addon_BDT_1084_Senyan_Hi))
{
AI_Output(other,self,"DIA_Addon_Esteban_MIS_15_07"); //Сеньян послал меня к тебе по этому делу.
AI_Output(self,other,"DIA_Addon_Esteban_MIS_07_08"); //Сеньян? Он тоже работает на меня. Я сказал ему, чтобы он смотрел в оба.
};
MIS_Judas = LOG_Running;
Log_CreateTopic(Topic_Addon_Esteban,LOG_MISSION);
Log_SetTopicStatus(Topic_Addon_Esteban,LOG_Running);
B_LogEntry(Topic_Addon_Esteban,"На жизнь Эстебана было совершено покушение. Я должен выяснить, кто за этим стоит.");
};
instance DIA_Addon_Esteban_Kerl(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 5;
condition = DIA_Addon_Esteban_Kerl_Condition;
information = DIA_Addon_Esteban_Kerl_Info;
permanent = FALSE;
description = "И что мне нужно сделать?";
};
func int DIA_Addon_Esteban_Kerl_Condition()
{
if(MIS_Judas == LOG_Running)
{
return TRUE;
};
};
func void DIA_Addon_Esteban_Kerl_Info()
{
AI_Output(other,self,"DIA_Addon_Esteban_Kerl_15_00"); //И что мне нужно сделать?
AI_Output(self,other,"DIA_Addon_Esteban_Kerl_07_01"); //Все в лагере знают об этом. Поэтому ты играешь в открытую.
AI_Output(self,other,"DIA_Addon_Esteban_Kerl_07_02"); //Постарайся выяснить, кто на моей стороне, а кто - против, и не дай ребятам себя обдурить!
AI_Output(self,other,"DIA_Addon_Esteban_Kerl_07_03"); //Поговори со Снафом. Этот жирный повар много знает.
B_LogEntry(Topic_Addon_Esteban,"Чтобы найти виновного, я должен поговорить с людьми в лагере и выяснить, на чьей они стороне. Снаф может мне помочь - ему многое известно.");
};
instance DIA_Addon_Esteban_Armor(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 9;
condition = DIA_Addon_Esteban_Armor_Condition;
information = DIA_Addon_Esteban_Armor_Info;
permanent = FALSE;
description = "Мне нужны доспехи получше.";
};
func int DIA_Addon_Esteban_Armor_Condition()
{
if(Huno_ArmorCheap == FALSE)
{
return TRUE;
};
};
func void DIA_Addon_Esteban_Armor_Info()
{
AI_Output(other,self,"DIA_Addon_Esteban_Armor_15_00"); //Мне нужны доспехи получше.
AI_Output(self,other,"DIA_Addon_Esteban_Armor_07_01"); //Зачем? У тебя уже есть доспехи, пока что вполне можешь обойтись ими!
if(MIS_Judas == LOG_Running)
{
AI_Output(self,other,"DIA_Addon_Esteban_Armor_07_02"); //Если ты выполнишь мое задание, мы поговорим об этом...
};
};
instance DIA_Addon_Esteban_Auftrag(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 99;
condition = DIA_Addon_Esteban_Auftrag_Condition;
information = DIA_Addon_Esteban_Auftrag_Info;
permanent = TRUE;
description = "По поводу задания...";
};
func int DIA_Addon_Esteban_Auftrag_Condition()
{
if(((MIS_Judas == LOG_Running) || (MIS_Judas == LOG_SUCCESS)) && (Bodyguard_Killer == FALSE))
{
return TRUE;
};
};
func void DIA_Addon_Esteban_Auftrag_Info()
{
AI_Output(other,self,"DIA_Addon_Esteban_Auftrag_15_00"); //По поводу задания...
AI_Output(self,other,"DIA_Addon_Esteban_Auftrag_07_01"); //Послушай, у меня есть и другие дела.
if(MIS_Judas == LOG_SUCCESS)
{
AI_Output(other,self,"DIA_Addon_Esteban_Auftrag_15_02"); //Я думал, тебе будет интересно, кто организовал нападение...
AI_Output(self,other,"DIA_Addon_Esteban_Auftrag_07_03"); //И кто же это? Скажи мне его имя - и мои ребята свернут ему шею...
AI_Output(other,self,"DIA_Addon_Esteban_Auftrag_15_04"); //Его организовал торговец Фиск. В данный момент он сидит в баре, пьет и ничего не подозревает...
AI_Output(self,other,"DIA_Addon_Esteban_Auftrag_07_05"); //ХА! Отличная работа, сынок. Мои охранники займутся им.
if(!Npc_IsDead(Wache_01) || !Npc_IsDead(Wache_02))
{
if(!Npc_IsDead(Wache_01))
{
AI_TurnToNPC(self,Wache_01);
}
else
{
AI_TurnToNPC(self,Wache_02);
};
AI_Output(self,other,"DIA_Addon_Esteban_Auftrag_07_06"); //Вы слышали, что он сказал, ребята. Пойдите и схватите Фиска.
AI_TurnToNPC(self,other);
};
Bodyguard_Killer = TRUE;
}
else
{
AI_Output(self,other,"DIA_Addon_Esteban_Auftrag_07_07"); //Возвращайся, когда ты выяснишь, кто стоит за нападением.
AI_StopProcessInfos(self);
};
};
instance DIA_Addon_Esteban_Away(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 5;
condition = DIA_Addon_Esteban_Away_Condition;
information = DIA_Addon_Esteban_Away_Info;
permanent = FALSE;
description = "И что теперь будет?";
};
func int DIA_Addon_Esteban_Away_Condition()
{
if(Bodyguard_Killer == TRUE)
{
return TRUE;
};
};
func void DIA_Addon_Esteban_Away_Info()
{
AI_Output(other,self,"DIA_Addon_Esteban_Away_15_00"); //И что теперь будет?
AI_Output(self,other,"DIA_Addon_Esteban_Away_07_01"); //Что теперь будет? Я скажу тебе, что будет.
AI_Output(self,other,"DIA_Addon_Esteban_Away_07_02"); //Фиск умрет мучительной смертью. И весь лагерь будет знать, за что.
AI_Output(self,other,"DIA_Addon_Esteban_Away_07_03"); //Это послужит им всем предупреждением.
B_StartOtherRoutine(Wache_01,"AMBUSH");
B_StartOtherRoutine(Wache_02,"AMBUSH");
};
instance DIA_Addon_Esteban_Stone(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 5;
condition = DIA_Addon_Esteban_Stone_Condition;
information = DIA_Addon_Esteban_Stone_Info;
permanent = FALSE;
description = "Могу я теперь получить красный камень?";
};
func int DIA_Addon_Esteban_Stone_Condition()
{
if(Npc_KnowsInfo(other,DIA_Addon_Esteban_Away) && (Bodyguard_Killer == TRUE))
{
return TRUE;
};
};
func void DIA_Addon_Esteban_Stone_Info()
{
AI_Output(other,self,"DIA_Addon_Esteban_Stone_15_00"); //Могу я теперь получить красный камень?
AI_Output(self,other,"DIA_Addon_Esteban_Stone_07_01"); //Ты хорошо справился с работой. Тебе нечего делать в шахте.
AI_Output(self,other,"DIA_Addon_Esteban_Stone_07_02"); //Я могу использовать тебя с большей выгодой. Ты останешься в лагере и будешь продолжать работать на меня.
};
instance DIA_Addon_Esteban_not(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 5;
condition = DIA_Addon_Esteban_not_Condition;
information = DIA_Addon_Esteban_not_Info;
permanent = FALSE;
description = "Я подумаю об этом.";
};
func int DIA_Addon_Esteban_not_Condition()
{
if(Npc_KnowsInfo(other,DIA_Addon_Esteban_Stone))
{
return TRUE;
};
};
func void DIA_Addon_Esteban_not_Info()
{
AI_Output(other,self,"DIA_Addon_Esteban_not_15_00"); //Я подумаю об этом.
AI_Output(self,other,"DIA_Addon_Esteban_not_07_01"); //Ты забыл, с кем ты разговариваешь. Я здесь главный, и тебе придется делать то, что я скажу.
AI_Output(self,other,"DIA_Addon_Esteban_not_07_02"); //А я сказал, что ты будешь работать на меня, а не на кого-нибудь еще. Это понятно?
};
instance DIA_Addon_Esteban_fight(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 6;
condition = DIA_Addon_Esteban_fight_Condition;
information = DIA_Addon_Esteban_fight_Info;
permanent = FALSE;
description = "Ты хочешь одурачить меня? И речи не было о том, чтобы я на тебя работал.";
};
func int DIA_Addon_Esteban_fight_Condition()
{
// if(Npc_KnowsInfo(other,DIA_Addon_Esteban_Stone) && (Npc_GetDistToWP(Wache_01,"BL_INN_OUTSIDE_01") <= 1000) && (Npc_GetDistToWP(Wache_02,"BL_INN_OUTSIDE_02") <= 1000))
if(Npc_KnowsInfo(other,DIA_Addon_Esteban_Stone))
{
return TRUE;
};
};
func void DIA_Addon_Esteban_fight_Info()
{
AI_Output(other,self,"DIA_Addon_Esteban_fight_15_00"); //Ты хочешь одурачить меня? И речи не было о том, чтобы я на тебя работал.
AI_Output(self,other,"DIA_Addon_Esteban_fight_07_01"); //Не каждый получает такое предложение. Но если оно тебе не нравится, ты можешь свободно покинуть лагерь...
AI_Output(other,self,"DIA_Addon_Esteban_fight_15_02"); //А может быть, ты сдержишь слово и дашь мне красный камень?
AI_Output(self,other,"DIA_Addon_Esteban_fight_07_03"); //Эй! Еще одно слово - и моим охранникам придется применить силу.
if(((Npc_GetDistToWP(Wache_01,"BL_INN_OUTSIDE_01") <= 1500) && (Npc_GetDistToWP(Wache_02,"BL_INN_OUTSIDE_02") <= 1500)) || (Npc_IsDead(Wache_01) && Npc_IsDead(Wache_02)))
{
AI_Output(other,self,"DIA_Addon_Esteban_fight_15_04"); //(ухмыляясь) Каким охранникам?
AI_Output(self,other,"DIA_Addon_Esteban_fight_07_05"); //Что?.. А, понятно, ты хочешь обвести меня... Ну, погоди...
}
else
{
AI_Output(other,self,"DIA_Addon_Esteban_Duell_15_00"); //Давай сюда камень СЕЙЧАС ЖЕ, или я заберу его сам!
B_Say(self,other,"$StupidBeastKilled");
};
Bodyguard_Killer = FALSE;
B_StartOtherRoutine(Wache_01,"TOT");
B_KillNpc(Wache_01);
B_StartOtherRoutine(Wache_02,"TOT");
B_KillNpc(Wache_02);
AI_StopProcessInfos(self);
B_Attack(self,other,AR_NONE,1);
};
instance DIA_Addon_Esteban_Duell(C_Info)
{
npc = BDT_1083_Addon_Esteban;
nr = 99;
condition = DIA_Addon_Esteban_Duell_Condition;
information = DIA_Addon_Esteban_Duell_Info;
permanent = FALSE;
description = "Давай сюда камень СЕЙЧАС ЖЕ, или я заберу его сам!";
};
func int DIA_Addon_Esteban_Duell_Condition()
{
if(Npc_KnowsInfo(other,DIA_Addon_Esteban_Rot) && (Bodyguard_Killer == FALSE))
{
return TRUE;
};
};
func void DIA_Addon_Esteban_Duell_Info()
{
AI_Output(other,self,"DIA_Addon_Esteban_Duell_15_00"); //Давай сюда камень СЕЙЧАС ЖЕ, или я заберу его сам!
AI_Output(self,other,"DIA_Addon_Esteban_Duell_07_01"); //О, у тебя есть последнее желание. Как мило. Я сделаю тебе одолжение и избавлю тебя от твоей тупости!
AI_StopProcessInfos(self);
B_Attack(self,other,AR_NONE,1);
if(Hlp_IsValidNpc(Wache_01) && !C_NpcIsDown(Wache_01) && (Npc_GetDistToNpc(Wache_01,other) <= 1500))
{
B_Attack(Wache_01,other,AR_NONE,1);
};
if(Hlp_IsValidNpc(Wache_02) && !C_NpcIsDown(Wache_02) && (Npc_GetDistToNpc(Wache_02,other) <= 1500))
{
B_Attack(Wache_02,other,AR_NONE,1);
};
};
|
D
|
/Users/seandorian/Code/PasswordStrength/Build/Intermediates/SwiftMigration/Password\ Strength/Intermediates.noindex/Password\ Strength.build/Debug-iphonesimulator/Password\ StrengthTests.build/Objects-normal/x86_64/NumberMappingTests.o : /Users/seandorian/Code/PasswordStrength/Password\ StrengthTests/MockNotificationCenter.swift /Users/seandorian/Code/PasswordStrength/Password\ Strength/NumberMappingTests.swift /Users/seandorian/Code/PasswordStrength/Password\ Strength/ViewControllerTests.swift /Users/seandorian/Code/PasswordStrength/Password\ Strength/String+EntropyTests.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotesc /Users/seandorian/Code/PasswordStrength/Build/Intermediates/SwiftMigration/Password\ Strength/Products/Debug-iphonesimulator/Password_Strength.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/XCTest.swiftmodule /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/Library/Frameworks/XCTest.framework/Modules/module.modulemap
/Users/seandorian/Code/PasswordStrength/Build/Intermediates/SwiftMigration/Password\ Strength/Intermediates.noindex/Password\ Strength.build/Debug-iphonesimulator/Password\ StrengthTests.build/Objects-normal/x86_64/NumberMappingTests~partial.swiftmodule : /Users/seandorian/Code/PasswordStrength/Password\ StrengthTests/MockNotificationCenter.swift /Users/seandorian/Code/PasswordStrength/Password\ Strength/NumberMappingTests.swift /Users/seandorian/Code/PasswordStrength/Password\ Strength/ViewControllerTests.swift /Users/seandorian/Code/PasswordStrength/Password\ Strength/String+EntropyTests.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotesc /Users/seandorian/Code/PasswordStrength/Build/Intermediates/SwiftMigration/Password\ Strength/Products/Debug-iphonesimulator/Password_Strength.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/XCTest.swiftmodule /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/Library/Frameworks/XCTest.framework/Modules/module.modulemap
/Users/seandorian/Code/PasswordStrength/Build/Intermediates/SwiftMigration/Password\ Strength/Intermediates.noindex/Password\ Strength.build/Debug-iphonesimulator/Password\ StrengthTests.build/Objects-normal/x86_64/NumberMappingTests~partial.swiftdoc : /Users/seandorian/Code/PasswordStrength/Password\ StrengthTests/MockNotificationCenter.swift /Users/seandorian/Code/PasswordStrength/Password\ Strength/NumberMappingTests.swift /Users/seandorian/Code/PasswordStrength/Password\ Strength/ViewControllerTests.swift /Users/seandorian/Code/PasswordStrength/Password\ Strength/String+EntropyTests.swift /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.apinotesc /Users/seandorian/Code/PasswordStrength/Build/Intermediates/SwiftMigration/Password\ Strength/Products/Debug-iphonesimulator/Password_Strength.swiftmodule/x86_64.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/ObjectiveC.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreImage.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/QuartzCore.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Dispatch.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Metal.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Darwin.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Foundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreFoundation.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/CoreGraphics.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/Swift.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/UIKit.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/SwiftOnoneSupport.swiftmodule /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/x86_64/XCTest.swiftmodule /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/Library/Frameworks/XCTest.framework/Modules/module.modulemap
|
D
|
instance DIA_Addon_Garaz_EXIT(C_Info)
{
npc = BDT_10024_Addon_Garaz;
nr = 999;
condition = DIA_Addon_Garaz_EXIT_Condition;
information = DIA_Addon_Garaz_EXIT_Info;
permanent = TRUE;
description = Dialog_Ende;
};
func int DIA_Addon_Garaz_EXIT_Condition()
{
return TRUE;
};
func void DIA_Addon_Garaz_EXIT_Info()
{
AI_StopProcessInfos(self);
};
instance DIA_Addon_Garaz_PICKPOCKET(C_Info)
{
npc = BDT_10024_Addon_Garaz;
nr = 900;
condition = DIA_Addon_Garaz_PICKPOCKET_Condition;
information = DIA_Addon_Garaz_PICKPOCKET_Info;
permanent = TRUE;
description = PICKPOCKET_COMM;
};
func int DIA_Addon_Garaz_PICKPOCKET_Condition()
{
return C_Beklauen(66,80);
};
func void DIA_Addon_Garaz_PICKPOCKET_Info()
{
Info_ClearChoices(DIA_Addon_Garaz_PICKPOCKET);
Info_AddChoice(DIA_Addon_Garaz_PICKPOCKET,Dialog_Back,DIA_Addon_Garaz_PICKPOCKET_BACK);
Info_AddChoice(DIA_Addon_Garaz_PICKPOCKET,DIALOG_PICKPOCKET,DIA_Addon_Garaz_PICKPOCKET_DoIt);
};
func void DIA_Addon_Garaz_PICKPOCKET_DoIt()
{
B_Beklauen();
Info_ClearChoices(DIA_Addon_Garaz_PICKPOCKET);
};
func void DIA_Addon_Garaz_PICKPOCKET_BACK()
{
Info_ClearChoices(DIA_Addon_Garaz_PICKPOCKET);
};
instance DIA_Addon_Garaz_Probleme(C_Info)
{
npc = BDT_10024_Addon_Garaz;
nr = 2;
condition = DIA_Addon_Garaz_Probleme_Condition;
information = DIA_Addon_Garaz_Probleme_Info;
permanent = FALSE;
important = TRUE;
};
func int DIA_Addon_Garaz_Probleme_Condition()
{
return TRUE;
};
func void DIA_Addon_Garaz_Probleme_Info()
{
AI_Output(self,other,"DIA_Addon_Garaz_Probleme_08_00"); //Подожди минутку.
AI_Output(other,self,"DIA_Addon_Garaz_Probleme_15_01"); //Есть какие-то проблемы?
AI_Output(self,other,"DIA_Addon_Garaz_Probleme_08_02"); //Ползуны! Множество ползунов. Мы напоролись на их гнездо!
};
instance DIA_Addon_Garaz_Hi(C_Info)
{
npc = BDT_10024_Addon_Garaz;
nr = 3;
condition = DIA_Addon_Garaz_Hi_Condition;
information = DIA_Addon_Garaz_Hi_Info;
permanent = FALSE;
description = "Почему мы не можем на них напасть?";
};
func int DIA_Addon_Garaz_Hi_Condition()
{
if((BLOODWYNISDEAD == FALSE) && (Minecrawler_Killed < 9))
{
return TRUE;
};
};
func void DIA_Addon_Garaz_Hi_Info()
{
AI_Output(other,self,"DIA_Addon_Garaz_Hi_15_00"); //Почему мы не можем на них напасть?
AI_Output(self,other,"DIA_Addon_Garaz_Hi_08_01"); //Я тоже спрашивал об этом. Но у охранников есть 'более важные дела'.
AI_Output(self,other,"DIA_Addon_Garaz_Hi_08_02"); //Бладвин поручил мне разобраться с этой проблемой.
AI_Output(other,self,"DIA_Addon_Garaz_Hi_15_03"); //Я полагаю, ты не собираешься с ними драться.
AI_Output(self,other,"DIA_Addon_Garaz_Hi_08_04"); //А зачем? Чтобы мы смогли добраться до золота в пещере?
AI_Output(self,other,"DIA_Addon_Garaz_Hi_08_05"); //Бладвин все равно заберет большую часть себе. И я не хочу рисковать собственной головой за свою ничтожную долю.
AI_Output(self,other,"DIA_Addon_Garaz_Hi_08_06"); //Если ТЫ хочешь сразиться с ползунами - даже не думай, что я тебя остановлю. Только не надо выманивать их сюда, ладно?
};
instance DIA_Addon_Garaz_Bloodwyn(C_Info)
{
npc = BDT_10024_Addon_Garaz;
nr = 8;
condition = DIA_Addon_Garaz_Bloodwyn_Condition;
information = DIA_Addon_Garaz_Bloodwyn_Info;
permanent = FALSE;
description = "Ты мне можешь рассказать что-нибудь про Бладвина?";
};
func int DIA_Addon_Garaz_Bloodwyn_Condition()
{
if(Npc_KnowsInfo(other,DIA_Addon_Garaz_Hi) && (Minecrawler_Killed < 9) && (BLOODWYNISDEAD == FALSE))
{
return TRUE;
};
};
func void DIA_Addon_Garaz_Bloodwyn_Info()
{
AI_Output(other,self,"DIA_Addon_Garaz_Bloodwyn_15_00"); //Ты мне можешь рассказать что-нибудь про Бладвина?
AI_Output(self,other,"DIA_Addon_Garaz_Bloodwyn_08_01"); //Могу. Он - жадный до золота ублюдок. Он проверяет каждую жилу и каждый самородок.
AI_Output(self,other,"DIA_Addon_Garaz_Bloodwyn_08_02"); //Он не может отвлечься от своей жажды золота. А нас он ни во что не ставит.
AI_Output(other,self,"DIA_Addon_Garaz_Bloodwyn_15_03"); //Что еще?
AI_Output(self,other,"DIA_Addon_Garaz_Bloodwyn_08_04"); //Он думает, что он - лучший и терпеть не может, если у кого-то больше денег, чем у него. Пожалуйста - я не встану у него на пути.
AI_Output(self,other,"DIA_Addon_Garaz_Bloodwyn_08_05"); //Просто не стой у него на пути и не провоцируй его, если не хочешь, чтобы он впал в ярость и перестал себя контролировать...
B_LogEntry(Topic_Addon_Tempel,"Если Бладвин узнает, что в шахте была открыта новая золотая жила, он наверняка покинет храм.");
B_LogEntry(Topic_Addon_Tempel,"Когда Бладвин рассержен, он теряет над собой контроль. Это может мне помочь.");
};
instance DIA_Addon_Garaz_Sieg(C_Info)
{
npc = BDT_10024_Addon_Garaz;
nr = 3;
condition = DIA_Addon_Garaz_Sieg_Condition;
information = DIA_Addon_Garaz_Sieg_Info;
permanent = FALSE;
description = "С ползунами покончено!";
};
func int DIA_Addon_Garaz_Sieg_Condition()
{
if((Minecrawler_Killed >= 9) && (BLOODWYNISDEAD == FALSE))
{
return TRUE;
};
};
func void DIA_Addon_Garaz_Sieg_Info()
{
AI_Output(other,self,"DIA_Addon_Garaz_Sieg_15_00"); //Ну, готово. С ползунами покончено!
AI_Output(self,other,"DIA_Addon_Garaz_Sieg_08_01"); //Бладвин уже идет сюда. Ты ведь этого хотел?
AI_Output(self,other,"DIA_Addon_Garaz_Sieg_08_02"); //Я хочу сказать, что ты перебил ползунов, чтобы Бладвин пришел сюда, да? Тогда, что бы ты ни планировал, делай это СЕЙЧАС.
B_StartOtherRoutine(Bloodwyn,"GOLD");
};
instance DIA_Addon_Garaz_Blood(C_Info)
{
npc = BDT_10024_Addon_Garaz;
nr = 3;
condition = DIA_Addon_Garaz_Blood_Condition;
information = DIA_Addon_Garaz_Blood_Info;
permanent = FALSE;
important = TRUE;
};
func int DIA_Addon_Garaz_Blood_Condition()
{
if((BLOODWYNISDEAD == TRUE) && Npc_IsInState(self,ZS_Talk))
{
return TRUE;
};
};
func void DIA_Addon_Garaz_Blood_Info()
{
AI_Output(self,other,"DIA_Addon_Garaz_Blood_08_00"); //Ты показал этому лодырю! Отличная работа.
AI_Output(self,other,"DIA_Addon_Garaz_Blood_08_01"); //Я пойду осмотрю пещеру.
B_GivePlayerXP(XP_Ambient);
AI_StopProcessInfos(self);
Npc_ExchangeRoutine(self,"GOLD");
B_StartOtherRoutine(Thorus,"TALK");
};
instance DIA_Addon_Garaz_Gold(C_Info)
{
npc = BDT_10024_Addon_Garaz;
nr = 3;
condition = DIA_Addon_Garaz_Gold_Condition;
information = DIA_Addon_Garaz_Gold_Info;
permanent = FALSE;
important = TRUE;
};
func int DIA_Addon_Garaz_Gold_Condition()
{
if((Npc_GetDistToWP(self,"ADW_MINE_MC_GARAZ") <= 500) && Npc_IsInState(self,ZS_Talk))
{
return TRUE;
};
};
func void DIA_Addon_Garaz_Gold_Info()
{
AI_Output(self,other,"DIA_Addon_Garaz_Gold_08_00"); //Ух ты, приятель! Здесь явно много золота!
AI_Output(self,other,"DIA_Addon_Garaz_Gold_08_01"); //Чтобы добраться до этих самородков, нам понадобится лестница.
};
|
D
|
/*
* inigear.d
*
* Copyright 2012 Igor Solkin
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*
*/
import std.stdio;
import std.string;
import std.ascii;
import std.file;
public class IniItem {
private string key;
private string value;
public static const char PAR_SYMBOL = '=';
this(string data) {
deserialize(data);
}
this(string key, string value) {
setKey(key);
setValue(value);
}
public void setKey(string key) {
this.key = key;
}
public string getKey() {
return key;
}
public void setValue(string value) {
this.value = value;
}
public string getValue() {
return value;
}
public string serialize() {
return getKey() ~ PAR_SYMBOL ~ getValue();
}
public void deserialize(string data) {
ulong parIndex = indexOf(data, PAR_SYMBOL);
setKey(data[0 .. parIndex]);
setValue(data[parIndex + 1 .. $]);
}
}
public class IniGroup {
private string name;
private IniItem[string] items;
public static const char LEFT_COMMA_SYMBOL = '[';
public static const char RIGHT_COMMA_SYMBOL = ']';
this() {
}
this(string name) {
setName(name);
}
public void setName(string name) {
this.name = name;
}
public string getName() {
return name;
}
public void addItem(string data) {
addItem(new IniItem(data));
}
public void addItem(string key, string value) {
addItem(new IniItem(key,value));
}
public void addItem(IniItem iniItem) {
items[iniItem.getKey()] = iniItem;
}
public IniItem getItem(string key) {
return items[key];
}
public IniItem[] getValues() {
return items.values;
}
public string[] getKeys() {
return items.keys;
}
public void removeItem(string key) {
items.remove(key);
}
public ulong getItemsCount() {
return items.length();
}
public string serialize() {
string data = LEFT_COMMA_SYMBOL ~ name ~ RIGHT_COMMA_SYMBOL;
for(int c=0; c < items.length; c++) {
data ~= newline ~ items.values[c].serialize;
}
return data;
}
public void deserialize(string data) {
deserialize(splitLines(data));
}
public int deserialize(string[] lines) {
items = items.init;
if(lines.length > 0) {
string group = lines[0];
if(assertIsGroup(group)) {
setName(group[1 .. $ - 1]);
int c;
while (++c < lines.length
&& !assertIsGroup(lines[c])) {
addItem(lines[c]);
}
return c;
}
}
return 0;
}
public static bool assertIsGroup(string line) {
return line[0] == LEFT_COMMA_SYMBOL
&& line[$ - 1] == RIGHT_COMMA_SYMBOL;
}
}
public class IniGear {
private IniGroup[string] groups;
public void addGroup(string name) {
addGroup(new IniGroup(name));
}
public void addGroup(IniGroup iniGroup) {
groups[iniGroup.getName()] = iniGroup;
}
public IniGroup getGroup(string key) {
return groups[key];
}
public string[] getGroupNames() {
return groups.keys;
}
public IniGroup[] getGroups() {
return groups.values;
}
public void removeGroup(string key) {
groups.remove(key);
}
public ulong getGroupsCount() {
return groups.length();
}
public string serialize() {
string data = "";
for(int c=0;c<groups.length;c++){
data ~= groups.values[c].serialize;
if(c < groups.length - 1) {
data ~= newline;
}
}
return data;
}
public void deserialize(string data) {
groups = groups.init;
string[] lines = splitLines(data);
if(lines.length > 0) {
ulong c = 0;
do {
IniGroup iniGroup = new IniGroup();
c += iniGroup.deserialize(lines[c .. $]);
addGroup(iniGroup);
} while(c < lines.length);
}
}
}
public class IniFile {
public static IniGear read(string path) {
IniGear iniGear = new IniGear();
iniGear.deserialize(readText(path));
return iniGear;
}
public static void write(string path, IniGear iniGear) {
//File file = File(path, "w");
//file.write(iniGear.serialize);
//file.flush();
//file.close();
std.file.write(path, iniGear.serialize());
}
}
|
D
|
void test()
{
int innerLocal = 20;
throw new Exception("foo");
}
void main(string[] args)
{
string myLocal = "bar";
test();
}
|
D
|
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2012 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
module dcsfml.Network.Types;
extern(System):
struct sfFtpDirectoryResponse;
struct sfFtpListingResponse;
struct sfFtpResponse;
struct sfFtp;
struct sfHttpRequest;
struct sfHttpResponse;
struct sfHttp;
struct sfPacket;
struct sfSocketSelector;
struct sfTcpListener;
struct sfTcpSocket;
struct sfUdpSocket;
|
D
|
module app;
import dlangui;
import rx;
import mvvm.common;
import mvvm.models.simple;
import mvvm.views.simple;
mixin APP_ENTRY_POINT;
/// entry point for dlangui based application
extern (C) int UIAppMain(string[] args)
{
auto window = Platform.instance.createWindow("Sample Window", null);
auto view = createSimpleView();
window.mainWidget = view;
auto viewModel = new SimpleViewModel;
// bind command and properties
bindText(view.childById!EditLine("txtTitle"), viewModel.title);
bindText(view.childById!TextWidget("lblTitle"), viewModel.title);
bind(view.childById!SwitchButton("switchIsActive"), viewModel.isActive);
bind(view.childById!Button("btnResetTitle"), viewModel.clearTitleCommand);
// show window
window.show();
// run message loop
return Platform.instance.enterMessageLoop();
}
|
D
|
/*
Copyright (c) 1996 Blake McBride
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <math.h>
defclass Number;
static double Round(double n, int p) /* round n to p places */
{
double r;
r = pow(10.0, (double) p);
r = floor(.5 + fabs(n * r)) / r;
if (n < 0.0) return(-r);
return(r);
}
static int Ndrgtb(double n, int b) /* returns the number of digits right of decimal point */
{
double base = b;
int i;
n = n < 0.0 ? -n : n;
i = 0;
while (i < 20) {
n -= floor(n);
if (1E-12 >= n) break;
i++;
n = Round(n*base, 13);
}
return(i);
}
/* Numeric formatter:
* r = Nfmtb(n, b, t, w, d, s);
* double n number to be formatted
* int b base
* char *t type of format - any combination of the following:
* B = blank if zero
* C = add commas
* L = left justify number
* P = put perenthises around negative numbers
* Z = zero fill
* D = floating dollar sign
* U = uppercase letters in conversion
* R = add a percent sign to the end of the number
*
* int w total field width
* ind d number of decimal places
* char s[w+1] result of format
* int r pointer to result of format
*
* example:
*
* r = Nfmt(-12345.348, "CP", 12, 2, s);
*
* result in s: (12,345.35)
*/
static char *Nfmtb(double n, int b, char *t, int wth, int d, char *s)
{
register int si, i;
int sign, blnk, comma, left, paren, zfill, nd, dol, tw, dl, ez, ucase, cf=3, w=wth, percent;
double base;
static char alpha[] = "0123456789abcdefghijklmnopqrstuvwxyz";
if (b < 2 || b > (int)(sizeof(alpha)-1))
b = 10;
base = b;
if (sign = n < 0.0)
n = -n;
/* round number */
if (d >= 0) {
double r = pow(base, (double) d);
// n = floor(base/20.0 + n * r) / r;
n = floor(.5 + n * r) / r;
}
switch (b) {
case 10:
cf = 3;
dl = n < 1.0 ? 0 : 1 + (int) log10(n); /* # of digits left of . */
break;
case 2:
cf = 4;
dl = n < 1.0 ? 0 : 1 + (int) (log(n)/.6931471806); /* # of digits left of . */
break;
case 8:
cf = 3;
dl = n < 1.0 ? 0 : 1 + (int) (log(n)/2.079441542); /* # of digits left of . */
break;
case 16:
cf = 4;
dl = n < 1.0 ? 0 : 1 + (int) (log(n)/2.772588722); /* # of digits left of . */
break;
default:
cf = 3;
dl = n < 1.0 ? 0 : 1 + (int) (log(n)/log(base)); /* # of digits left of . */
break;
}
if (d < 0)
d = Ndrgtb(n, b);
blnk = comma = left = paren = zfill = dol = ucase = percent = 0;
if (t)
while (*t)
switch (*t++) {
case 'B': blnk = 1; break;
case 'C': comma = (dl - 1) / cf; break;
case 'L': left = 1; break;
case 'P': paren = 1; break;
case 'Z': zfill = 1; break;
case 'D': dol = 1; break;
case 'U': ucase = 1; break;
case 'R': percent = 1; break;
}
/* calculate what the number should take up */
ez = n < 1.0;
tw = dol + paren + comma + sign + dl + d + !!d + ez + percent;
if (w < 1)
w = tw;
else if (tw > w) {
if (ez)
tw -= ez--;
if ((i=dol) && tw > w)
tw -= dol--;
if (tw > w && comma) {
tw -= comma;
comma = 0;
}
if (tw < w && i) {
tw++;
dol = 1;
}
if (tw > w && paren)
tw -= paren--;
if (tw > w && percent)
tw -= percent--;
if (tw > w) {
nofit:
for (i=0 ; i < w ; )
s[i++] = '*';
s[i] = '\0';
return(s);
}
}
n = floor(.5 + n * floor(.5 + pow(base, (double) d)));
if (blnk && n == 0.0) {
for (i=0 ; i < wth ; )
s[i++] = ' ';
s[wth] = '\0';
return(s);
}
s[si = w] = '\0';
if (left && w > tw) {
i = w - tw;
while (i--)
s[--si] = ' ';
}
if (paren)
s[--si] = sign ? ')' : ' ';
if (percent)
s[--si] = '%';
for (nd=0 ; nd < d && si ; nd++) {
n /= base;
i = (int) floor(base * (n - floor(n)) + .5);
n = floor(n);
s[--si] = ucase && i > 9 ? alpha[i]+('A'-'a') : alpha[i];
}
if (d)
if (si)
s[--si] = '.';
else
n = 1.0;
if (ez && si > sign + dol)
s[--si] = '0';
nd = 0;
while (n > 0.0 && si)
if (comma && nd == cf) {
s[--si] = ',';
nd = 0;
} else {
n /= base;
i = (int) floor(base * (n - floor(n)) + .5);
n = floor(n);
s[--si] = ucase && i > 9 ? alpha[i]+('A'-'a') : alpha[i];
nd++;
}
if (zfill) {
i = sign + dol;
while (si > i)
s[--si] = '0';
}
if (dol && si)
s[--si] = '$';
if (sign)
if (si)
s[--si] = paren ? '(' : '-';
else
n = 1.0; /* signal error condition */
while (si)
s[--si] = ' ';
if (n != 0.0)
goto nofit; /* should never happen. but just incase */
return(s);
}
imeth gFormatNumber, <vFormat> (char *msk, int wth, int dp)
{
char buf[80];
Nfmtb(gDoubleValue(self), 10, msk, wth, dp, buf);
return gNewWithStr(String, buf);
}
#if 0
//imeth int gHash()
{
double t;
t = .6125423371 * gDoubleValue(self);
t = t < 0.0 ? -t : t;
return (int) (BIG_INT * (t - floor(t)));
}
#endif
imeth int gCompare(obj)
{
double sv, ov;
ChkArg(obj, 2);
if (!gIsKindOf(obj, Number))
return gCompare(super, obj);
if ((sv=gDoubleValue(self)) < (ov=gDoubleValue(obj)))
return -1;
else if (sv == ov)
return 0;
else
return 1;
}
|
D
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.