static inline void field(char & f, const Field & v, char def = '\0')
{
f = v.empty() ? def : v[0];
}
/** Compute the elastic (large!) deformation of a block of material.
* See problem description in ref06::PulledSheetProblem for a the boundary
* conditions. The problem is non-linear and therefore a Newton method is
* used. Moreover, the applied load (displacement or traction) is divided into
* load steps.
*
* New features:
* - vectorial problem: DoFs are not scalar anymore
* - hyper-elasticity
*
*/
int ref06::compressible( int argc, char * argv[] )
{
// basic attributes of the computation
const unsigned geomDeg = 1;
const unsigned fieldDeg = 2;
const base::Shape shape = base::HyperCubeShape<SPACEDIM>::value;
// typedef mat::hypel::StVenant Material;
typedef mat::hypel::NeoHookeanCompressible Material;
// usage message
if ( argc != 3 ) {
std::cout << "Usage: " << argv[0] << " mesh.smf input.dat \n";
return 0;
}
// read name of input file
const std::string meshFile = boost::lexical_cast<std::string>( argv[1] );
const std::string inputFile = boost::lexical_cast<std::string>( argv[2] );
// read from input file
double E, nu, pull, traction, tolerance;
unsigned maxIter, loadSteps;
bool dispControlled;
{
//Feed properties parser with the variables to be read
base::io::PropertiesParser prop;
prop.registerPropertiesVar( "E", E );
prop.registerPropertiesVar( "nu", nu );
prop.registerPropertiesVar( "pull", pull );
prop.registerPropertiesVar( "maxIter", maxIter );
prop.registerPropertiesVar( "loadSteps", loadSteps );
prop.registerPropertiesVar( "traction", traction );
prop.registerPropertiesVar( "dispControlled", dispControlled );
prop.registerPropertiesVar( "tolerance", tolerance );
// Read variables from the input file
std::ifstream inp( inputFile.c_str() );
VERIFY_MSG( inp.is_open(), "Cannot open input file" );
prop.readValues( inp );
inp.close( );
// Make sure all variables have been found
if ( not prop.isEverythingRead() ) {
prop.writeUnread( std::cerr );
VERIFY_MSG( false, "Could not find above variables" );
}
}
// find base name from mesh file
const std::string baseName = base::io::baseName( meshFile, ".smf" );
//--------------------------------------------------------------------------
// define a mesh
typedef base::Unstructured<shape,geomDeg> Mesh;
const unsigned dim = Mesh::Node::dim;
// create a mesh and read from input
Mesh mesh;
{
std::ifstream smf( meshFile.c_str() );
base::io::smf::readMesh( smf, mesh );
smf.close();
}
// quadrature objects for volume and surface
const unsigned kernelDegEstimate = 3;
typedef base::Quadrature<kernelDegEstimate,shape> Quadrature;
Quadrature quadrature;
typedef base::SurfaceQuadrature<kernelDegEstimate,shape> SurfaceQuadrature;
SurfaceQuadrature surfaceQuadrature;
// Create a field
const unsigned doFSize = dim;
typedef base::fe::Basis<shape,fieldDeg> FEBasis;
typedef base::Field<FEBasis,doFSize> Field;
typedef Field::DegreeOfFreedom DoF;
Field field;
// generate DoFs from mesh
base::dof::generate<FEBasis>( mesh, field );
// Creates a list of <Element,faceNo> pairs along the boundary
base::mesh::MeshBoundary meshBoundary;
meshBoundary.create( mesh.elementsBegin(), mesh.elementsEnd() );
// Create a boundary mesh from this list
typedef base::mesh::BoundaryMeshBinder<Mesh::Element>::Type BoundaryMesh;
BoundaryMesh boundaryMesh;
{
// Create a real mesh object from this list
base::mesh::generateBoundaryMesh( meshBoundary.begin(),
meshBoundary.end(),
mesh, boundaryMesh );
}
// initial pull = (total amount) / (number of steps)
const double firstPull = pull / static_cast<double>( loadSteps );
// constrain the boundary
base::dof::constrainBoundary<FEBasis>( meshBoundary.begin(),
meshBoundary.end(),
mesh, field,
boost::bind(
&ref06::PulledSheet<dim>::dirichletBC<DoF>,
_1, _2, dispControlled, firstPull ) );
// Bind the fields together
typedef base::asmb::FieldBinder<Mesh,Field> FieldBinder;
FieldBinder fieldBinder( mesh, field );
typedef FieldBinder::TupleBinder<1,1>::Type FTB;
typedef base::asmb::SurfaceFieldBinder<BoundaryMesh,Field> SurfaceFieldBinder;
SurfaceFieldBinder surfaceFieldBinder( boundaryMesh, field );
typedef SurfaceFieldBinder::TupleBinder<1>::Type SFTB;
// material object
Material material( mat::Lame::lambda( E, nu), mat::Lame::mu( E, nu ) );
// matrix kernel
typedef solid::HyperElastic<Material,FTB::Tuple> HyperElastic;
HyperElastic hyperElastic( material );
// Number the degrees of freedom
const std::size_t numDofs =
base::dof::numberDoFsConsecutively( field.doFsBegin(), field.doFsEnd() );
std::cout << "# Number of dofs " << numDofs << std::endl;
// create table for writing the convergence behaviour of the nonlinear solves
base::io::Table<4>::WidthArray widths = {{ 2, 5, 5, 15 }};
base::io::Table<4> table( widths );
table % "Step" % "Iter" % "|F|" % "|x|";
std::cout << "#" << table;
// write a vtk file
ref06::writeVTKFile( baseName, 0, mesh, field, material );
//--------------------------------------------------------------------------
// Loop over load steps
//--------------------------------------------------------------------------
for ( unsigned step = 0; step < loadSteps; step++ ) {
// rescale constraints in every load step: (newValue / oldValue)
const double pullFactor =
(step == 0 ?
static_cast<double>( step+1 ) :
static_cast<double>( step+1 )/ static_cast<double>(step) );
// scale constraints
base::dof::scaleConstraints( field, pullFactor );
//----------------------------------------------------------------------
// Nonlinear iterations
//----------------------------------------------------------------------
unsigned iter = 0;
while ( iter < maxIter ) {
table % step % iter;
// Create a solver object
typedef base::solver::Eigen3 Solver;
Solver solver( numDofs );
// apply traction boundary condition, if problem is not disp controlled
if ( not dispControlled ) {
// value of applied traction
const double tractionFactor =
traction *
static_cast<double>(step+1) / static_cast<double>( loadSteps );
// apply traction load
base::asmb::neumannForceComputation<SFTB>(
surfaceQuadrature, solver,
surfaceFieldBinder,
boost::bind( &ref06::PulledSheet<dim>::neumannBC,
_1, _2, tractionFactor ) );
}
// residual forces
base::asmb::computeResidualForces<FTB>( quadrature, solver,
fieldBinder,
hyperElastic );
// Compute element stiffness matrices and assemble them
base::asmb::stiffnessMatrixComputation<FTB>( quadrature, solver,
fieldBinder,
hyperElastic );
// Finalise assembly
solver.finishAssembly();
// norm of residual
const double conv1 = solver.norm();
table % conv1;
// convergence via residual norm
if ( conv1 < tolerance * E ) { // note the tolerance multiplier
std::cout << table;
break;
}
// Solve
//solver.choleskySolve();
solver.cgSolve();
// distribute results back to dofs
base::dof::addToDoFsFromSolver( solver, field );
// norm of displacement increment
const double conv2 = solver.norm();
table % conv2;
std::cout << table;
iter++;
// convergence via increment
if ( conv2 < tolerance ) break;
}
// Finished non-linear iterations
//----------------------------------------------------------------------
// warning
if ( iter == maxIter ) {
std::cout << "# (WW) Step " << step << " has not converged within "
<< maxIter << " iterations \n";
}
// write a vtk file
ref06::writeVTKFile( baseName, step+1, mesh, field, material );
}
// Finished load steps
//--------------------------------------------------------------------------
return 0;
}
int removeElementsConditional(Field& conditionalField)
{
return Cmiss_mesh_group_remove_elements_conditional(
reinterpret_cast<Cmiss_mesh_group_id>(id), conditionalField.getId());
}
Real VolumeIntegral::integrate(const Field& field, const std::vector< Handle<Entities> >& entities)
{
Real local_integral = 0.;
boost_foreach( const Handle<Entities>& patch, entities )
{
if( patch->element_type().dimensionality() != patch->element_type().dimension() )
throw SetupError( FromHere(), "Cannot compute Volume integral of surface element");
if( is_not_null(m_quadrature) )
remove_component("quadrature");
m_quadrature = create_component<Quadrature>("quadrature",
"cf3.mesh.gausslegendre."+GeoShape::Convert::instance().to_str(patch->element_type().shape())+"P"+common::to_str(m_order));
/// Common part for every element of this patch
const Space& space = field.space(*patch);
const Uint nb_elems = space.size();
const Uint nb_nodes_per_elem = space.shape_function().nb_nodes();
const Uint nb_qdr_pts = m_quadrature->nb_nodes();
const Uint nb_vars = field.row_size();
RealMatrix qdr_pt_values( nb_qdr_pts, nb_vars );
RealMatrix interpolate( nb_qdr_pts, nb_nodes_per_elem );
RealMatrix field_pt_values( nb_nodes_per_elem, nb_vars );
RealMatrix elem_coords;
patch->geometry_space().allocate_coordinates(elem_coords);
for( Uint qn=0; qn<nb_qdr_pts; ++qn)
{
interpolate.row(qn) = space.shape_function().value( m_quadrature->local_coordinates().row(qn) );
}
/// Loop over every element of this patch
for (Uint e=0; e<nb_elems; ++e)
{
if( ! patch->is_ghost(e) )
{
patch->geometry_space().put_coordinates(elem_coords,e);
// interpolate
for (Uint n=0; n<nb_nodes_per_elem; ++n)
{
const Uint p = space.connectivity()[e][n];
for (Uint v=0; v<nb_vars; ++v)
{
field_pt_values(n,v) = field[p][v];
}
}
qdr_pt_values = interpolate * field_pt_values;
// integrate
for( Uint qn=0; qn<nb_qdr_pts; ++qn)
{
const Real Jdet = patch->element_type().jacobian_determinant( m_quadrature->local_coordinates().row(qn), elem_coords );
local_integral += Jdet * m_quadrature->weights()[qn] * qdr_pt_values(qn,0);
}
}
}
}
Real global_integral;
PE::Comm::instance().all_reduce(PE::plus(), &local_integral, 1, &global_integral);
return global_integral;
}
void WritePly(const std::vector<CVector<3,double> >& result, const Field<2,float>& mask, std::string filename)
{
// generate face indices
Field<2,int> index(mask.size());
for (int y=0, idx=0; y<mask.size(1); y++)
for (int x=0; x<mask.size(0); x++)
if (mask.cell(x,y))
index.cell(x,y)=idx++;
else
index.cell(x,y)=-1;
std::vector<CVector<3,int> > face;
for (int y=0; y<mask.size(1)-1; y++)
{
for (int x=0; x<mask.size(0)-1; x++)
{
// sore in CCW order
if (mask.cell(x,y) && mask.cell(x+1,y) && mask.cell(x+1,y+1) &&
!distorted(index.cell(x,y),index.cell(x+1,y),index.cell(x+1,y+1),result))
face.push_back(make_vector(index.cell(x,y),index.cell(x+1,y+1),index.cell(x+1,y)));
if (mask.cell(x,y) && mask.cell(x+1,y+1) && mask.cell(x,y+1) &&
!distorted(index.cell(x,y),index.cell(x+1,y+1),index.cell(x,y+1),result))
face.push_back(make_vector(index.cell(x,y),index.cell(x,y+1),index.cell(x+1,y+1)));
}
}
TRACE("ply => %s\n",filename.c_str());
FILE *fw = fopen(filename.c_str(), "wb");
fprintf(fw,
"ply\n"
"format binary_little_endian 1.0\n"
"element vertex %d\n"
"property float x\n"
"property float y\n"
"property float z\n"
"element face %d\n"
"property list uchar int vertex_indices\n"
"end_header\n", result.size(), face.size());
for (int i=0; i<result.size(); i++)
{
CVector<3,float> p = make_vector(result[i][0],result[i][1],result[i][2]);
fwrite(&p, 12, 1, fw);
}
for (int i=0; i<face.size(); i++)
{
fputc(3,fw);
fwrite(&face[i], 12, 1, fw);
}
fclose(fw);
}
bool FieldsReader::doc(int32_t n, Document* doc)
{
if ( n * 8L > indexStream->length() )
return false;
indexStream->seek(n * 8L);
int64_t position = indexStream->readLong();
fieldsStream->seek(position);
int32_t numFields = fieldsStream->readVInt();
for (int32_t i = 0; i < numFields; i++) {
int32_t fieldNumber = fieldsStream->readVInt();
FieldInfo* fi = fieldInfos->fieldInfo(fieldNumber);
if ( fi == NULL )
_CLTHROWA(CL_ERR_IO, "Field stream is invalid");
uint8_t bits = fieldsStream->readByte();
if ((bits & FieldsWriter::FIELD_IS_BINARY) != 0) {
int32_t fieldLen = fieldsStream->readVInt();
FieldsReader::FieldsStreamHolder* subStream = new
FieldsReader::FieldsStreamHolder(fieldsStream, fieldLen);
uint8_t bits = Field::STORE_YES;
Field* f = _CLNEW Field(
fi->name, // name
subStream, // read value
bits);
doc->add(*f);
//now skip over the rest of the field
if (fieldsStream->getFilePointer() + fieldLen
== fieldsStream->length()) {
// set to eof
fieldsStream->seek(fieldsStream->getFilePointer() + fieldLen - 1);
fieldsStream->readByte();
} else {
fieldsStream->seek(fieldsStream->getFilePointer() + fieldLen);
}
} else {
uint8_t bits = Field::STORE_YES;
if (fi->isIndexed && (bits & FieldsWriter::FIELD_IS_TOKENIZED)!=0 )
bits |= Field::INDEX_TOKENIZED;
else if (fi->isIndexed && (bits & FieldsWriter::FIELD_IS_TOKENIZED) == 0)
bits |= Field::INDEX_UNTOKENIZED;
else
bits |= Field::INDEX_NO;
if (fi->storeTermVector) {
if (fi->storeOffsetWithTermVector) {
if (fi->storePositionWithTermVector) {
bits |= Field::TERMVECTOR_WITH_OFFSETS;
bits |= Field::TERMVECTOR_WITH_POSITIONS;
} else {
bits |= Field::TERMVECTOR_WITH_OFFSETS;
}
} else if (fi->storePositionWithTermVector) {
bits |= Field::TERMVECTOR_WITH_POSITIONS;
} else {
bits |= Field::TERMVECTOR_YES;
}
} else {
bits |= Field::TERMVECTOR_NO;
}
if ( (bits & FieldsWriter::FIELD_IS_COMPRESSED) != 0 ) {
bits |= Field::STORE_COMPRESS;
int32_t fieldLen = fieldsStream->readVInt();
FieldsStreamHolder* subStream = new
FieldsStreamHolder(fieldsStream, fieldLen);
// TODO: we dont have gzip inputstream available, must alert
// user to somehow use a gzip inputstream
Field* f = _CLNEW Field(
fi->name, // name
subStream, // read value
bits);
f->setOmitNorms(fi->omitNorms);
doc->add(*f);
// now skip over the rest of the field
if (fieldsStream->getFilePointer() + fieldLen
== fieldsStream->length()) {
//set to eof
fieldsStream->seek(fieldsStream->getFilePointer() + fieldLen - 1);
fieldsStream->readByte();
} else {
fieldsStream->seek(fieldsStream->getFilePointer() + fieldLen);
}
} else {
TCHAR* fvalue = fieldsStream->readString(true);
Field* f = _CLNEW Field(
fi->name, // name
fvalue, // read value
bits);
// TODO: could optimise this
_CLDELETE_CARRAY(fvalue);
f->setOmitNorms(fi->omitNorms);
doc->add(*f);
}
}
}
return true;
}
bool fieldTest() {
Class A(NULL, "A");
ASSERT_NO_THROW(A.addStaticField("static", INT));
ASSERT_EQUALS("static", A.getField("static").name());
ASSERT_EQUALS("A", A.getField("static").getDeclaringClass());
ASSERT_EQUALS(INT, A.getField("static").getType());
Object* inst1 = A.newInstance();
ASSERT_NO_THROW(A.addInstanceField("field", INT));
Field f = A.getField("field");
Field exist = A.getField("static");
ASSERT_THROW(FieldNotFound, f.setInt(inst1, 4));
ASSERT_NO_THROW(exist.setInt(inst1, 555));
Class::setAccessible(true);
ASSERT_THROW(FieldNotFound, f.setInt(inst1, 4));
ASSERT_THROW(FieldNotFound, f.getInt(inst1));
ASSERT_THROW(TypeError, f.setObj(inst1,NULL));
ASSERT_THROW(TypeError, f.getObj(inst1));
Object* inst2 = A.newInstance();
ASSERT_NO_THROW(f.setInt(inst2, 17));
ASSERT_NO_THROW(exist.getInt(inst1));
ASSERT_EQUALS(exist.getInt(inst1), 555);
ASSERT_EQUALS(f.getInt(inst2), 17);
ASSERT_THROW(TypeError, f.setObj(inst2,NULL));
ASSERT_THROW(TypeError, f.getObj(inst2));
Class::setAccessible(false);
/* delete inst1;
delete inst2;*/
return true;
}
void operator ()(Field &f, const Data &d) {
f.sub(f, d);
}
void StorageDistributed::reshardPartitions(ASTPtr query, const String & database_name,
const Field & first_partition, const Field & last_partition,
const WeightedZooKeeperPaths & weighted_zookeeper_paths,
const ASTPtr & sharding_key_expr, bool do_copy, const Field & coordinator,
const Settings & settings)
{
auto & resharding_worker = context.getReshardingWorker();
if (!resharding_worker.isStarted())
throw Exception{"Resharding background thread is not running", ErrorCodes::RESHARDING_NO_WORKER};
if (!coordinator.isNull())
throw Exception{"Use of COORDINATE WITH is forbidden in ALTER TABLE ... RESHARD"
" queries for distributed tables",
ErrorCodes::RESHARDING_INVALID_PARAMETERS};
std::string coordinator_id = resharding_worker.createCoordinator(cluster);
std::atomic<bool> has_notified_error{false};
std::string dumped_coordinator_state;
auto handle_exception = [&](const std::string & msg = "")
{
try
{
if (!has_notified_error)
resharding_worker.setStatus(coordinator_id, ReshardingWorker::STATUS_ERROR, msg);
dumped_coordinator_state = resharding_worker.dumpCoordinatorState(coordinator_id);
resharding_worker.deleteCoordinator(coordinator_id);
}
catch (...)
{
tryLogCurrentException(__PRETTY_FUNCTION__);
}
};
try
{
/// Создать запрос ALTER TABLE ... RESHARD [COPY] PARTITION ... COORDINATE WITH ...
ASTPtr alter_query_ptr = std::make_shared<ASTAlterQuery>();
auto & alter_query = static_cast<ASTAlterQuery &>(*alter_query_ptr);
alter_query.database = remote_database;
alter_query.table = remote_table;
alter_query.parameters.emplace_back();
ASTAlterQuery::Parameters & parameters = alter_query.parameters.back();
parameters.type = ASTAlterQuery::RESHARD_PARTITION;
if (!first_partition.isNull())
parameters.partition = std::make_shared<ASTLiteral>(StringRange(), first_partition);
if (!last_partition.isNull())
parameters.last_partition = std::make_shared<ASTLiteral>(StringRange(), last_partition);
ASTPtr expr_list = std::make_shared<ASTExpressionList>();
for (const auto & entry : weighted_zookeeper_paths)
{
ASTPtr weighted_path_ptr = std::make_shared<ASTWeightedZooKeeperPath>();
auto & weighted_path = static_cast<ASTWeightedZooKeeperPath &>(*weighted_path_ptr);
weighted_path.path = entry.first;
weighted_path.weight = entry.second;
expr_list->children.push_back(weighted_path_ptr);
}
parameters.weighted_zookeeper_paths = expr_list;
parameters.sharding_key_expr = sharding_key_expr;
parameters.do_copy = do_copy;
parameters.coordinator = std::make_shared<ASTLiteral>(StringRange(), Field(coordinator_id));
resharding_worker.registerQuery(coordinator_id, queryToString(alter_query_ptr));
/** Функциональность shard_multiplexing не доделана - выключаем её.
* (Потому что установка соединений с разными шардами в рамках одного потока выполняется не параллельно.)
* Подробнее смотрите в https://███████████.yandex-team.ru/METR-18300
*/
bool enable_shard_multiplexing = false;
ClusterProxy::AlterQueryConstructor alter_query_constructor;
BlockInputStreams streams = ClusterProxy::Query{alter_query_constructor, cluster, alter_query_ptr,
context, settings, enable_shard_multiplexing} .execute();
/// This callback is called if an exception has occurred while attempting to read
/// a block from a shard. This is to avoid a potential deadlock if other shards are
/// waiting inside a barrier. Actually, even without this solution, we would avoid
/// such a deadlock because we would eventually time out while trying to get remote
/// blocks. Nevertheless this is not the ideal way of sorting out this issue since
/// we would then not get to know the actual cause of the failure.
auto exception_callback = [&resharding_worker, coordinator_id, &has_notified_error]()
{
try
{
resharding_worker.setStatus(coordinator_id, ReshardingWorker::STATUS_ERROR);
has_notified_error = true;
}
catch (...)
{
tryLogCurrentException(__PRETTY_FUNCTION__);
}
};
streams[0] = std::make_shared<UnionBlockInputStream<>>(
streams, nullptr, settings.max_distributed_connections, exception_callback);
streams.resize(1);
auto stream_ptr = dynamic_cast<IProfilingBlockInputStream *>(&*streams[0]);
if (stream_ptr == nullptr)
throw Exception{"StorageDistributed: Internal error", ErrorCodes::LOGICAL_ERROR};
auto & stream = *stream_ptr;
stream.readPrefix();
while (!stream.isCancelled() && stream.read())
;
if (!stream.isCancelled())
stream.readSuffix();
}
catch (const Exception & ex)
{
handle_exception(ex.message());
LOG_ERROR(log, dumped_coordinator_state);
throw;
}
catch (const std::exception & ex)
{
handle_exception(ex.what());
LOG_ERROR(log, dumped_coordinator_state);
throw;
}
catch (...)
{
handle_exception();
LOG_ERROR(log, dumped_coordinator_state);
throw;
}
}
void operator ()(MeterArray &meter_array, const Data &idx, Field &dst) {
dst.set(meter_array.execute_meter(get_packet(), idx.get_uint()));
}
void operator ()(Field &dst, const RegisterArray &src, const Data &idx) {
dst.set(src[idx.get_uint()]);
}
int main(int argc, char **argv)
{
#ifdef BENCHMARK
//benchmarking variables
double start_time, ref_time, ref2_time, cycle_start_time;
double initialization_time;
double run_time;
double cycle_time=0;
double projection_time = 0;
double snapshot_output_time = 0;
double spectra_output_time = 0;
double gravity_solver_time = 0;
double fft_time = 0;
int fft_count = 0;
double update_q_time = 0;
int update_q_count = 0;
double moveParts_time = 0;
int moveParts_count =0;
#endif //BENCHMARK
int n = 0, m = 0;
int io_size = 0;
int io_group_size = 0;
int i, j, cycle = 0, snapcount = 0, pkcount = 0, usedparams, numparam = 0, doneTT, redo_psi = 0, numsteps;
int numsteps_ncdm[MAX_PCL_SPECIES];
long numpts3d;
int box[3];
double dtau, dtau_old, dx, tau, a, fourpiG, tau_Lambda, maxvel;
double maxvel_ncdm[MAX_PCL_SPECIES];
FILE * outfile;
char filename[2*PARAM_MAX_LENGTH+24];
char buffer[64];
string h5filename;
char * settingsfile = NULL;
parameter * params = NULL;
metadata sim;
cosmology cosmo;
icsettings ic;
gadget2_header hdr;
Real * kbin;
Real * power;
Real * kscatter;
Real * pscatter;
int * occupation;
int numbins;
Real divB, curlB, divh, traceh, normh, T00hom;
Cplx tempk;
for (i=1 ; i < argc ; i++ ){
if ( argv[i][0] != '-' )
continue;
switch(argv[i][1]) {
case 's':
settingsfile = argv[++i]; //settings file name
break;
case 'n':
n = atoi(argv[++i]); //size of the dim 1 of the processor grid
break;
case 'm':
m = atoi(argv[++i]); //size of the dim 2 of the processor grid
break;
case 'i':
#ifndef EXTERNAL_IO
cout << "EXTERNAL_IO needs to be set at compilation to use the I/O server"<<endl;
exit(-1000);
#endif
io_size = atoi(argv[++i]);
break;
case 'g':
#ifndef EXTERNAL_IO
cout << "EXTERNAL_IO needs to be set at compilation to use the I/O server"<<endl;
exit(-1000);
#endif
io_group_size = atoi(argv[++i]);
}
}
#ifndef EXTERNAL_IO
parallel.initialize(n,m);
#else
parallel.initialize(n,m,io_size,io_group_size);
if(parallel.isIO()) ioserver.start();
else
{
#endif
COUT << " _ _ _ __ , _" << endl;
COUT << " (_| (-' \\/ (_) (_ (_| ( ( (_) /\\/ version 1.0 running on " << n*m << " cores." << endl;
COUT << " -'" << endl << endl;
if (settingsfile == NULL)
{
COUT << " error: no settings file specified!" << endl;
parallel.abortForce();
}
COUT << " initializing..." << endl;
#ifdef BENCHMARK
start_time = MPI_Wtime();
#endif
numparam = loadParameterFile(settingsfile, params);
usedparams = parseMetadata(params, numparam, sim, cosmo, ic);
COUT << " parsing of settings file completed. " << numparam << " parameters found, " << usedparams << " were used." << endl;
sprintf(filename, "%s%s_settings_used.ini", sim.output_path, sim.basename_generic);
saveParameterFile(filename, params, numparam);
free(params);
h5filename.reserve(2*PARAM_MAX_LENGTH);
h5filename.assign(sim.output_path);
h5filename += sim.basename_snapshot;
box[0] = sim.numpts;
box[1] = sim.numpts;
box[2] = sim.numpts;
Lattice lat(3,box,1);
Lattice latFT;
latFT.initializeRealFFT(lat,0);
Particles_gevolution<part_simple,part_simple_info,part_simple_dataType> pcls_cdm;
Particles_gevolution<part_simple,part_simple_info,part_simple_dataType> pcls_ncdm[MAX_PCL_SPECIES];
Field<Real> * update_cdm_fields[3];
Field<Real> * update_ncdm_fields[3];
double f_params[5];
Field<Real> phi;
Field<Real> psi;
Field<Real> source;
Field<Real> chi;
Field<Real> Sij;
Field<Real> Bi;
Field<Cplx> scalarFT;
Field<Cplx> SijFT;
Field<Cplx> BiFT;
source.initialize(lat,1);
psi.initialize(lat,1);
phi.initialize(lat,1);
chi.initialize(lat,1);
scalarFT.initialize(latFT,1);
PlanFFT<Cplx> plan_source(&source, &scalarFT);
PlanFFT<Cplx> plan_psi(&psi, &scalarFT);
PlanFFT<Cplx> plan_phi(&phi, &scalarFT);
PlanFFT<Cplx> plan_chi(&chi, &scalarFT);
Sij.initialize(lat,3,3,symmetric);
SijFT.initialize(latFT,3,3,symmetric);
PlanFFT<Cplx> plan_Sij(&Sij, &SijFT);
Bi.initialize(lat,3);
BiFT.initialize(latFT,3);
PlanFFT<Cplx> plan_Bi(&Bi, &BiFT);
#ifdef CHECK_B
Field<Real> Bi_check;
Field<Cplx> BiFT_check;
Bi_check.initialize(lat,3);
BiFT_check.initialize(latFT,3);
PlanFFT<Cplx> plan_Bi_check(&Bi_check, &BiFT_check);
#endif
update_cdm_fields[0] = ψ
update_cdm_fields[1] = φ
update_cdm_fields[2] = &Bi;
update_ncdm_fields[0] = ψ
update_ncdm_fields[1] = φ
update_ncdm_fields[2] = &Bi;
Site x(lat);
rKSite kFT(latFT);
dx = 1.0 / (double) sim.numpts;
numpts3d = (long) sim.numpts * (long) sim.numpts * (long) sim.numpts;
for (i = 0; i < 3; i++) // particles may never move farther than to the adjacent domain
{
if (lat.sizeLocal(i)-1 < sim.movelimit)
sim.movelimit = lat.sizeLocal(i)-1;
}
parallel.min(sim.movelimit);
fourpiG = 1.5 * sim.boxsize * sim.boxsize / 2997.92458 / 2997.92458;
a = 1. / (1. + sim.z_in);
tau = 2. / Hconf(a, fourpiG, cosmo);
tau_Lambda = -1.0;
if (sim.Cf * dx < sim.steplimit / Hconf(a, fourpiG, cosmo))
dtau = sim.Cf * dx;
else
dtau = sim.steplimit / Hconf(a, fourpiG, cosmo);
dtau_old = dtau;
if (ic.generator == ICGEN_BASIC)
maxvel = generateIC_basic(sim, ic, cosmo, fourpiG, dtau, &pcls_cdm, pcls_ncdm, maxvel_ncdm, &phi, &psi, &chi, &Bi, &source, &Sij, &scalarFT, &BiFT, &SijFT, &plan_phi, &plan_psi, &plan_chi, &plan_Bi, &plan_source, &plan_Sij); // generates ICs on the fly
#ifdef ICGEN_PREVOLUTION
else if (ic.generator == ICGEN_PREVOLUTION)
{
maxvel = generateIC_prevolution(sim, ic, cosmo, fourpiG, a, &pcls_cdm, pcls_ncdm, maxvel_ncdm, &phi, &psi, &chi, &Bi, &source, &Sij, &scalarFT, &BiFT, &SijFT, &plan_phi, &plan_psi, &plan_chi, &plan_Bi, &plan_source, &plan_Sij);
}
#endif
#ifdef ICGEN_FALCONIC
else if (ic.generator == ICGEN_FALCONIC)
{
maxvel = generateIC_FalconIC(sim, ic, cosmo, fourpiG, dtau, &pcls_cdm, pcls_ncdm, maxvel_ncdm, &phi, &psi, &chi, &Bi, &source, &Sij, &scalarFT, &BiFT, &SijFT, &plan_phi, &plan_psi, &plan_chi, &plan_Bi, &plan_source, &plan_Sij);
}
#endif
else
{
COUT << " error: IC generator not implemented!" << endl;
parallel.abortForce();
}
parallel.max<double>(maxvel);
if (cosmo.num_ncdm > 0) parallel.max<double>(maxvel_ncdm, cosmo.num_ncdm);
if (sim.gr_flag > 0)
{
maxvel /= sqrt(maxvel * maxvel + 1.0);
for (i = 0; i < cosmo.num_ncdm; i++)
maxvel_ncdm[i] /= sqrt(maxvel_ncdm[i] * maxvel_ncdm[i] + 1.0);
}
kbin = (Real *) malloc(sim.numbins * sizeof(Real));
power = (Real *) malloc(sim.numbins * sizeof(Real));
kscatter = (Real *) malloc(sim.numbins * sizeof(Real));
pscatter = (Real *) malloc(sim.numbins * sizeof(Real));
occupation = (int *) malloc(sim.numbins * sizeof(int));
for (i = 0; i < 6; i++)
{
hdr.npart[i] = 0;
hdr.npartTotal[i] = 0;
hdr.mass[i] = 0.;
}
hdr.num_files = 1;
hdr.Omega0 = cosmo.Omega_m;
hdr.OmegaLambda = 1. - cosmo.Omega_m;
hdr.HubbleParam = cosmo.h;
hdr.BoxSize = sim.boxsize * 1000.;
hdr.flag_sfr = 0;
hdr.flag_cooling = 0;
hdr.flag_feedback = 0;
for (i = 0; i < 256 - 6 * 4 - 6 * 8 - 2 * 8 - 2 * 4 - 6 * 4 - 2 * 4 - 4 * 8; i++)
hdr.fill[i] = 0;
#ifdef BENCHMARK
initialization_time = MPI_Wtime() - start_time;
parallel.sum(initialization_time);
COUT << " initialization complete. BENCHMARK: " << hourMinSec(initialization_time) << endl << endl;
#else
COUT << " initialization complete." << endl << endl;
#endif
while (true) // main loop
{
#ifdef BENCHMARK
cycle_start_time = MPI_Wtime();
#endif
// construct stress-energy tensor
projection_init(&source);
if (sim.gr_flag > 0)
{
projection_T00_project(&pcls_cdm, &source, a, &phi);
for (i = 0; i < cosmo.num_ncdm; i++)
projection_T00_project(pcls_ncdm+i, &source, a, &phi);
}
else
{
scalarProjectionCIC_project(&pcls_cdm, &source);
for (i = 0; i < cosmo.num_ncdm; i++)
scalarProjectionCIC_project(pcls_ncdm+i, &source);
}
projection_T00_comm(&source);
projection_init(&Sij);
projection_Tij_project(&pcls_cdm, &Sij, a, &phi);
for (i = 0; i < cosmo.num_ncdm; i++)
projection_Tij_project(pcls_ncdm+i, &Sij, a, &phi);
projection_Tij_comm(&Sij);
doneTT = 0;
#ifdef BENCHMARK
projection_time += MPI_Wtime() - cycle_start_time;
ref_time = MPI_Wtime();
#endif
// snapshot output
if (snapcount < sim.num_snapshot && 1. / a < sim.z_snapshot[snapcount] + 1.)
{
sprintf(filename, "%03d", snapcount);
snapcount++;
COUT << " writing snapshot at z = " << ((1./a) - 1.) << " (cycle " << cycle << "), tau/boxsize = " << tau << endl;
#ifdef EXTERNAL_IO
while (ioserver.openOstream()== OSTREAM_FAIL);
if (sim.out_snapshot & MASK_PCLS)
pcls_cdm.saveHDF5_server_open(h5filename + filename + "_part");
if (sim.out_snapshot & MASK_DBARE && sim.gr_flag > 0)
psi.saveHDF5_server_open(h5filename + filename + "_deltaN");
if (sim.out_snapshot & MASK_T00)
source.saveHDF5_server_open(h5filename + filename + "_T00");
if (sim.out_snapshot & MASK_B)
Bi.saveHDF5_server_open(h5filename + filename + "_B");
if (sim.out_snapshot & MASK_PHI)
phi.saveHDF5_server_open(h5filename + filename + "_phi");
if (sim.out_snapshot & MASK_CHI)
chi.saveHDF5_server_open(h5filename + filename + "_chi");
if (sim.out_snapshot & MASK_HIJ)
Sij.saveHDF5_server_open(h5filename + filename + "_hij");
#ifdef CHECK_B
if (sim.out_snapshot & MASK_B)
Bi_check.saveHDF5_server_open(h5filename + filename + "_B_check");
#endif
#endif
if (sim.out_snapshot & MASK_DBARE)
{
if (sim.gr_flag > 0)
{
projection_init(&psi);
scalarProjectionCIC_project(&pcls_cdm, &psi);
for (i = 0; i < cosmo.num_ncdm; i++)
scalarProjectionCIC_project(pcls_ncdm+i, &psi);
scalarProjectionCIC_comm(&psi);
#ifdef EXTERNAL_IO
psi.saveHDF5_server_write(NUMBER_OF_IO_FILES);
#else
psi.saveHDF5(h5filename + filename + "_deltaN.h5");
#endif
redo_psi = 1;
}
else
source.saveHDF5(h5filename + filename + "_deltaN.h5");
}
if (sim.out_snapshot & MASK_POT)
{
if (!redo_psi)
{
projection_init(&psi);
scalarProjectionCIC_project(&pcls_cdm, &psi);
for (i = 0; i < cosmo.num_ncdm; i++)
scalarProjectionCIC_project(pcls_ncdm+i, &psi);
scalarProjectionCIC_comm(&psi);
redo_psi = 1;
}
plan_psi.execute(FFT_FORWARD);
solveModifiedPoissonFT(scalarFT, scalarFT, fourpiG / a);
plan_psi.execute(FFT_BACKWARD);
psi.saveHDF5(h5filename + filename + "_psiN.h5");
}
if (sim.out_snapshot & MASK_T00)
#ifdef EXTERNAL_IO
source.saveHDF5_server_write(NUMBER_OF_IO_FILES);
#else
source.saveHDF5(h5filename + filename + "_T00.h5");
#endif
if (sim.out_snapshot & MASK_B)
{
if (sim.gr_flag == 0)
{
plan_Bi.execute(FFT_BACKWARD);
}
for (x.first(); x.test(); x.next())
{
Bi(x,0) /= a * a * sim.numpts;
Bi(x,1) /= a * a * sim.numpts;
Bi(x,2) /= a * a * sim.numpts;
}
Bi.updateHalo();
computeVectorDiagnostics(Bi, divB, curlB);
COUT << " B diagnostics: max |divB| = " << divB << ", max |curlB| = " << curlB << endl;
#ifdef EXTERNAL_IO
Bi.saveHDF5_server_write(NUMBER_OF_IO_FILES);
#else
Bi.saveHDF5(h5filename + filename + "_B.h5");
#endif
if (sim.gr_flag > 0)
{
plan_Bi.execute(FFT_BACKWARD);
Bi.updateHalo();
}
}
if (sim.out_snapshot & MASK_PHI)
#ifdef EXTERNAL_IO
phi.saveHDF5_server_write(NUMBER_OF_IO_FILES);
#else
phi.saveHDF5(h5filename + filename + "_phi.h5");
#endif
if (sim.out_snapshot & MASK_CHI)
#ifdef EXTERNAL_IO
chi.saveHDF5_server_write(NUMBER_OF_IO_FILES);
#else
chi.saveHDF5(h5filename + filename + "_chi.h5");
#endif
if (sim.out_snapshot & MASK_TIJ)
Sij.saveHDF5(h5filename + filename + "_Tij.h5");
if (sim.out_snapshot & MASK_HIJ)
{
projectFTtensor(SijFT, SijFT);
doneTT = 1;
plan_Sij.execute(FFT_BACKWARD);
Sij.updateHalo();
computeTensorDiagnostics(Sij, divh, traceh, normh);
COUT << " GW diagnostics: max |divh| = " << divh << ", max |traceh| = " << traceh << ", max |h| = " << normh << endl;
#ifdef EXTERNAL_IO
Sij.saveHDF5_server_write(NUMBER_OF_IO_FILES);
#else
Sij.saveHDF5(h5filename + filename + "_hij.h5");
#endif
projection_init(&Sij);
projection_Tij_project(&pcls_cdm, &Sij, a, &phi);
for (i = 0; i < cosmo.num_ncdm; i++)
projection_Tij_project(pcls_ncdm+i, &Sij, a, &phi);
projection_Tij_comm(&Sij);
}
if (sim.out_snapshot & MASK_P)
{
#ifdef CHECK_B
projection_init(&Bi_check);
vectorProjectionCICNGP_project(&pcls_cdm, &Bi_check);
for (i = 0; i < cosmo.num_ncdm; i++)
vectorProjectionCICNGP_project(pcls_ncdm+i, &Bi_check);
vectorProjectionCICNGP_comm(&Bi_check);
Bi_check.saveHDF5(h5filename + filename + "_p.h5");
#else
projection_init(&Bi);
vectorProjectionCICNGP_project(&pcls_cdm, &Bi);
for (i = 0; i < cosmo.num_ncdm; i++)
vectorProjectionCICNGP_project(pcls_ncdm+i, &Bi);
vectorProjectionCICNGP_comm(&Bi);
Bi.saveHDF5(h5filename + filename + "_p.h5");
if (sim.gr_flag > 0)
{
plan_Bi.execute(FFT_BACKWARD);
Bi.updateHalo();
}
#endif
}
#ifdef CHECK_B
if (sim.out_snapshot & MASK_B)
{
if (!(sim.out_snapshot & MASK_P))
{
projection_init(&Bi_check);
vectorProjectionCICNGP_project(&pcls_cdm, &Bi_check);
for (i = 0; i < cosmo.num_ncdm; i++)
vectorProjectionCICNGP_project(pcls_ncdm+i, &Bi_check);
vectorProjectionCICNGP_comm(&Bi_check);
}
plan_Bi_check.execute(FFT_FORWARD);
projectFTvector(BiFT_check, BiFT_check, fourpiG * dx * dx);
plan_Bi_check.execute(FFT_BACKWARD);
for (x.first(); x.test(); x.next())
{
Bi_check(x,0) /= a * a * sim.numpts;
Bi_check(x,1) /= a * a * sim.numpts;
Bi_check(x,2) /= a * a * sim.numpts;
}
#ifdef EXTERNAL_IO
Bi_check.saveHDF5_server_write(NUMBER_OF_IO_FILES);
#else
Bi_check.saveHDF5(h5filename + filename + "_B_check.h5");
#endif
}
#endif
if (sim.out_snapshot & MASK_GADGET)
{
hdr.time = a;
hdr.redshift = (1./a) - 1.;
hdr.npart[1] = (unsigned int) (sim.numpcl[0] / sim.tracer_factor[0]);
hdr.npartTotal[1] = hdr.npart[1];
hdr.mass[1] = (double) sim.tracer_factor[0] * 27.7459457 * (cosmo.Omega_cdm + cosmo.Omega_b) * sim.boxsize * sim.boxsize * sim.boxsize / sim.numpcl[0];
pcls_cdm.saveGadget2(h5filename + filename + "_part.dat", hdr, sim.tracer_factor[0]);
for (i = 0; i < cosmo.num_ncdm; i++)
{
sprintf(buffer, "_ncdm%d.dat", i);
hdr.npart[1] = (unsigned int) (sim.numpcl[i+1] / sim.tracer_factor[i+1]);
hdr.npartTotal[1] = hdr.npart[1];
hdr.mass[1] = (double) sim.tracer_factor[i+1] * 27.7459457 * cosmo.Omega_ncdm[i] * sim.boxsize * sim.boxsize * sim.boxsize / sim.numpcl[i+1];
pcls_ncdm[i].saveGadget2(h5filename + filename + buffer, hdr, sim.tracer_factor[i+1]);
}
}
if (sim.out_snapshot & MASK_PCLS)
{
#ifdef EXTERNAL_IO
pcls_cdm.saveHDF5_server_write();
#else
pcls_cdm.saveHDF5(h5filename + filename + "_part", 1);
#endif
}
#ifdef EXTERNAL_IO
ioserver.closeOstream();
#endif
} // snapshot output done
#ifdef BENCHMARK
snapshot_output_time += MPI_Wtime() - ref_time;
ref_time = MPI_Wtime();
#endif
// power spectra
if (pkcount < sim.num_pk && 1. / a < sim.z_pk[pkcount] + 1.)
{
pkcount++;
COUT << " writing power spectra at z = " << ((1./a) - 1.) << " (cycle " << cycle << "), tau/boxsize = " << tau << endl;
if (sim.out_pk & MASK_DBARE || sim.out_pk & MASK_POT || (sim.out_pk & MASK_T00 && sim.gr_flag == 0))
{
if (!redo_psi && sim.gr_flag > 0)
{
projection_init(&psi);
scalarProjectionCIC_project(&pcls_cdm, &psi);
for (i = 0; i < cosmo.num_ncdm; i++)
scalarProjectionCIC_project(pcls_ncdm+i, &psi);
scalarProjectionCIC_comm(&psi);
redo_psi = 1;
plan_psi.execute(FFT_FORWARD);
}
else if (sim.gr_flag > 0)
{
plan_psi.execute(FFT_FORWARD);
}
else
{
plan_source.execute(FFT_FORWARD);
}
if (sim.out_pk & MASK_DBARE || (sim.out_pk & MASK_T00 && sim.gr_flag == 0))
extractPowerSpectrum(scalarFT, kbin, power, kscatter, pscatter, occupation, sim.numbins, true, KTYPE_LINEAR);
if (sim.out_pk & MASK_DBARE)
{
sprintf(filename, "%s%s%03d_deltaN.dat", sim.output_path, sim.basename_pk, pkcount-1);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, "power spectrum of delta", a);
}
if (sim.out_pk & MASK_T00 && sim.gr_flag == 0)
{
sprintf(filename, "%s%s%03d_T00.dat", sim.output_path, sim.basename_pk, pkcount-1);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, "power spectrum of T00", a);
}
if (sim.out_pk & MASK_POT)
{
solveModifiedPoissonFT(scalarFT, scalarFT, fourpiG / a);
extractPowerSpectrum(scalarFT, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_psiN.dat", sim.output_path, sim.basename_pk, pkcount-1);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, "power spectrum of psi_N", a);
}
if (cosmo.num_ncdm > 0 && (sim.out_pk & MASK_DBARE || (sim.out_pk & MASK_T00 && sim.gr_flag == 0)))
{
redo_psi = 1;
projection_init(&psi);
scalarProjectionCIC_project(&pcls_cdm, &psi);
scalarProjectionCIC_comm(&psi);
plan_psi.execute(FFT_FORWARD);
extractPowerSpectrum(scalarFT, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_cdm.dat", sim.output_path, sim.basename_pk, pkcount-1);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, "power spectrum of delta for cdm", a);
for (i = 0; i < cosmo.num_ncdm; i++)
{
projection_init(&psi);
scalarProjectionCIC_project(pcls_ncdm+i, &psi);
scalarProjectionCIC_comm(&psi);
plan_psi.execute(FFT_FORWARD);
extractPowerSpectrum(scalarFT, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_ncdm%d.dat", sim.output_path, sim.basename_pk, pkcount-1, i);
sprintf(buffer, "power spectrum of delta for ncdm %d", i);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, buffer, a);
#ifdef CHECK_B
// store k-space information for cross-spectra using BiFT_check as temporary array
if (cosmo.num_ncdm > 1 && i < cosmo.num_ncdm-1 && i < 3)
{
for (kFT.first(); kFT.test(); kFT.next())
BiFT_check(kFT, i) = scalarFT(kFT);
}
#endif
}
#ifdef CHECK_B
for (i = 0; i < cosmo.num_ncdm-1 && i < 3; i++)
{
if (i > 0)
{
for (kFT.first(); kFT.test(); kFT.next())
scalarFT(kFT) = BiFT_check(kFT, i);
}
for (j = i+1; j < cosmo.num_ncdm && j <= 3; j++)
{
if (j > i+1)
{
for (kFT.first(); kFT.test(); kFT.next())
{
tempk = BiFT_check(kFT, 0);
BiFT_check(kFT, 0) = BiFT_check(kFT, j-1);
BiFT_check(kFT, j-1) = tempk;
}
}
extractCrossSpectrum(scalarFT, BiFT_check, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_ncdm%dx%d.dat", sim.output_path, sim.basename_pk, pkcount-1, i, j);
if (cosmo.num_ncdm < 4)
sprintf(buffer, "cross power spectrum of delta for ncdm %d x %d", (i+cosmo.num_ncdm-1)%cosmo.num_ncdm, (j+cosmo.num_ncdm-1)%cosmo.num_ncdm);
else
sprintf(buffer, "cross power spectrum of delta for ncdm %d x %d", (6-11*i+5*i*i)/2, i ? 4-j : (j+3)%4);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, buffer, a);
}
}
#endif
}
}
if (sim.out_pk & MASK_PHI)
{
plan_phi.execute(FFT_FORWARD);
extractPowerSpectrum(scalarFT, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_phi.dat", sim.output_path, sim.basename_pk, pkcount-1);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, "power spectrum of phi", a);
}
if (sim.out_pk & MASK_CHI)
{
plan_chi.execute(FFT_FORWARD);
extractPowerSpectrum(scalarFT, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_chi.dat", sim.output_path, sim.basename_pk, pkcount-1);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, "power spectrum of chi", a);
}
if (sim.out_pk & MASK_HIJ)
{
if (!doneTT)
projectFTtensor(SijFT, SijFT);
extractPowerSpectrum(SijFT, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_hij.dat", sim.output_path, sim.basename_pk, pkcount-1);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, 2. * M_PI * M_PI, filename, "power spectrum of hij", a);
}
if (sim.out_pk & MASK_T00 && sim.gr_flag > 0)
{
plan_source.execute(FFT_FORWARD);
extractPowerSpectrum(scalarFT, kbin, power, kscatter, pscatter, occupation, sim.numbins, true, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_T00.dat", sim.output_path, sim.basename_pk, pkcount-1);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, "power spectrum of T00", a);
if (cosmo.num_ncdm > 0)
{
redo_psi = 1;
projection_init(&psi);
projection_T00_project(&pcls_cdm, &psi, a, &phi);
projection_T00_comm(&psi);
plan_psi.execute(FFT_FORWARD);
extractPowerSpectrum(scalarFT, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_T00cdm.dat", sim.output_path, sim.basename_pk, pkcount-1);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, "power spectrum of T00 for cdm", a);
for (i = 0; i < cosmo.num_ncdm; i++)
{
projection_init(&psi);
projection_T00_project(pcls_ncdm+i, &psi, a, &phi);
projection_T00_comm(&psi);
plan_psi.execute(FFT_FORWARD);
extractPowerSpectrum(scalarFT, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_T00ncdm%d.dat", sim.output_path, sim.basename_pk, pkcount-1, i);
sprintf(buffer, "power spectrum of T00 for ncdm %d", i);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, buffer, a);
#ifdef CHECK_B
// store k-space information for cross-spectra using BiFT_check as temporary array
if (cosmo.num_ncdm > 1 && i < 3)
{
for (kFT.first(); kFT.test(); kFT.next())
BiFT_check(kFT, i) = scalarFT(kFT);
}
#endif
}
#ifdef CHECK_B
for (i = 0; i < cosmo.num_ncdm-1 && i < 3; i++)
{
if (i > 0)
{
for (kFT.first(); kFT.test(); kFT.next())
scalarFT(kFT) = BiFT_check(kFT, i);
}
for (j = i+1; j < cosmo.num_ncdm && j <=3; j++)
{
if (j > i+1)
{
for (kFT.first(); kFT.test(); kFT.next())
{
tempk = BiFT_check(kFT, 0);
BiFT_check(kFT, 0) = BiFT_check(kFT, j-1);
BiFT_check(kFT, j-1) = tempk;
}
}
extractCrossSpectrum(scalarFT, BiFT_check, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_T00ncdm%dx%d.dat", sim.output_path, sim.basename_pk, pkcount-1, i, j);
if (cosmo.num_ncdm < 4)
sprintf(buffer, "cross power spectrum of T00 for ncdm %d x %d", (i+cosmo.num_ncdm-1)%cosmo.num_ncdm, (j+cosmo.num_ncdm-1)%cosmo.num_ncdm);
else
sprintf(buffer, "cross power spectrum of T00 for ncdm %d x %d", (6-11*i+5*i*i)/2, i ? 4-j : (j+3)%4);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, (Real) numpts3d * (Real) numpts3d * 2. * M_PI * M_PI, filename, buffer, a);
}
}
#endif
}
}
if (sim.out_pk & MASK_B)
{
extractPowerSpectrum(BiFT, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_B.dat", sim.output_path, sim.basename_pk, pkcount-1);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, a * a * a * a * sim.numpts * sim.numpts * 2. * M_PI * M_PI, filename, "power spectrum of B", a);
#ifdef CHECK_B
projection_init(&Bi_check);
vectorProjectionCICNGP_project(&pcls_cdm,&Bi_check);
for (i = 0; i < cosmo.num_ncdm; i++)
vectorProjectionCICNGP_project(pcls_ncdm+i, &Bi_check);
vectorProjectionCICNGP_comm(&Bi_check);
plan_Bi_check.execute(FFT_FORWARD);
projectFTvector(BiFT_check, BiFT_check, fourpiG * dx * dx);
extractPowerSpectrum(BiFT_check, kbin, power, kscatter, pscatter, occupation, sim.numbins, false, KTYPE_LINEAR);
sprintf(filename, "%s%s%03d_B_check.dat", sim.output_path, sim.basename_pk, pkcount-1);
writePowerSpectrum(kbin, power, kscatter, pscatter, occupation, sim.numbins, sim.boxsize, a * a * a * a * sim.numpts * sim.numpts * 2. * M_PI * M_PI, filename, "power spectrum of B", a);
#endif
}
} // power spectra done
#ifdef BENCHMARK
spectra_output_time += MPI_Wtime() - ref_time;
ref_time = MPI_Wtime();
#endif
if (sim.gr_flag > 0)
{
if (redo_psi)
{
for (x.first(); x.test(); x.next())
psi(x) = phi(x) - chi(x);
redo_psi = 0;
}
T00hom = 0.;
for (x.first(); x.test(); x.next())
T00hom += source(x);
parallel.sum<Real>(T00hom);
T00hom /= (Real) numpts3d;
if (cycle % 10 == 0)
{
COUT << " cycle " << cycle << ", background information: z = " << (1./a) - 1. << ", average T00 = " << T00hom << ", background model = " << cosmo.Omega_cdm + cosmo.Omega_b + bg_ncdm(a, cosmo) << endl;
}
prepareFTsource<Real>(phi, psi, source, cosmo.Omega_cdm + cosmo.Omega_b + bg_ncdm(a, cosmo), source, 3. * Hconf(a, fourpiG, cosmo) * dx * dx / dtau_old, fourpiG * dx * dx / a, 3. * Hconf(a, fourpiG, cosmo) * Hconf(a, fourpiG, cosmo) * dx * dx); // prepare nonlinear source for phi update
#ifdef BENCHMARK
ref2_time= MPI_Wtime();
#endif
plan_source.execute(FFT_FORWARD); // go to k-space
#ifdef BENCHMARK
fft_time += MPI_Wtime() - ref2_time;
fft_count++;
#endif
solveModifiedPoissonFT(scalarFT, scalarFT, 1. / (dx * dx), 3. * Hconf(a, fourpiG, cosmo) / dtau_old); // phi update (k-space)
}
else
{
#ifdef BENCHMARK
ref2_time= MPI_Wtime();
#endif
plan_source.execute(FFT_FORWARD); // Newton: directly go to k-space
#ifdef BENCHMARK
fft_time += MPI_Wtime() - ref2_time;
fft_count++;
#endif
solveModifiedPoissonFT(scalarFT, scalarFT, fourpiG / a); // Newton: phi update (k-space)
}
#ifdef BENCHMARK
ref2_time= MPI_Wtime();
#endif
plan_phi.execute(FFT_BACKWARD); // go back to position space
#ifdef BENCHMARK
fft_time += MPI_Wtime() - ref2_time;
fft_count++;
#endif
phi.updateHalo(); // communicate halo values
// record some background data
if (kFT.setCoord(0, 0, 0))
{
sprintf(filename, "%s%s_background.dat", sim.output_path, sim.basename_generic);
outfile = fopen(filename, "a");
if (outfile == NULL)
{
cout << " error opening file for background output!" << endl;
}
else
{
if (cycle == 0)
fprintf(outfile, "# background statistics\n# cycle tau/boxsize a conformal H/H0 phi(k=0) T00(k=0)\n");
fprintf(outfile, " %6d %e %e %e %e %e\n", cycle, tau, a, Hconf(a, fourpiG, cosmo) / Hconf(1., fourpiG, cosmo), scalarFT(kFT).real(), T00hom);
fclose(outfile);
}
}
// done recording background data
if (pkcount >= sim.num_pk && snapcount >= sim.num_snapshot) break; // simulation complete
prepareFTsource<Real>(phi, Sij, Sij, 2. * fourpiG * dx * dx / a); // prepare nonlinear source for additional equations
#ifdef BENCHMARK
ref2_time= MPI_Wtime();
#endif
plan_Sij.execute(FFT_FORWARD); // go to k-space
#ifdef BENCHMARK
fft_time += MPI_Wtime() - ref2_time;
fft_count += 6;
#endif
projectFTscalar(SijFT, scalarFT); // construct chi by scalar projection (k-space)
evolveFTvector(SijFT, BiFT, a * a * dtau_old); // evlolve B using vector projection (k-space)
#ifdef BENCHMARK
ref2_time= MPI_Wtime();
#endif
plan_chi.execute(FFT_BACKWARD); // go back to position space
#ifdef BENCHMARK
fft_time += MPI_Wtime() - ref2_time;
fft_count++;
#endif
chi.updateHalo(); // communicale halo values
if (sim.gr_flag > 0)
{
for (x.first(); x.test(); x.next()) // update psi
psi(x) = phi(x) - chi(x);
#ifdef BENCHMARK
ref2_time= MPI_Wtime();
#endif
plan_Bi.execute(FFT_BACKWARD); // go back to position space
#ifdef BENCHMARK
fft_time += MPI_Wtime() - ref2_time;
fft_count += 3;
#endif
Bi.updateHalo(); // communicate halo values
}
else
{
for (x.first(); x.test(); x.next()) // Newton: update psi
psi(x) = phi(x);
}
psi.updateHalo(); // communicate halo values
// compute number of step subdivisions for particle updates
numsteps = 1;
for (i = 0; i < cosmo.num_ncdm; i++)
{
if (dtau * maxvel_ncdm[i] > dx * sim.movelimit)
numsteps_ncdm[i] = (int) ceil(dtau * maxvel_ncdm[i] / dx / sim.movelimit);
else numsteps_ncdm[i] = 1;
if (numsteps < numsteps_ncdm[i]) numsteps = numsteps_ncdm[i];
}
if (numsteps > 1 && numsteps % 2 > 0) numsteps++; // if >1, make it an even number
for (i = 0; i < cosmo.num_ncdm; i++)
{
if (numsteps / numsteps_ncdm[i] <= 1) numsteps_ncdm[i] = numsteps;
else if (numsteps_ncdm[i] > 1) numsteps_ncdm[i] = numsteps / 2;
}
if (cycle % 10 == 0)
{
COUT << " cycle " << cycle << ", time integration information: max |v| = " << maxvel << " (cdm Courant factor = " << maxvel * sim.Cf << "), time step / Hubble time = " << Hconf(a, fourpiG, cosmo) * dtau;
for (i = 0; i < cosmo.num_ncdm; i++)
{
if (i == 0)
{
COUT << endl << " time step subdivision for ncdm species: ";
}
COUT << numsteps_ncdm[i] << " (max |v| = " << maxvel_ncdm[i] << ")";
if (i < cosmo.num_ncdm-1)
{
COUT << ", ";
}
}
COUT << endl;
}
for (j = 0; j < numsteps; j++) // particle update
{
#ifdef BENCHMARK
ref2_time = MPI_Wtime();
#endif
f_params[0] = a;
f_params[1] = a * a * sim.numpts;
if (j == 0)
{
if (sim.gr_flag > 0)
maxvel = pcls_cdm.updateVel(update_q, (dtau + dtau_old) / 2., update_cdm_fields, (1. / a < ic.z_relax + 1. ? 3 : 1), f_params);
else
maxvel = pcls_cdm.updateVel(update_q_Newton, (dtau + dtau_old) / 2., update_cdm_fields, 1, f_params);
#ifdef BENCHMARK
update_q_count++;
#endif
}
for (i = 0; i < cosmo.num_ncdm; i++)
{
if (j % (numsteps / numsteps_ncdm[i]) == 0)
{
if (sim.gr_flag > 0)
maxvel_ncdm[i] = pcls_ncdm[i].updateVel(update_q, (dtau + dtau_old) / 2. / numsteps_ncdm[i], update_ncdm_fields, (1. / a < ic.z_relax + 1. ? 3 : 2), f_params);
else
maxvel_ncdm[i] = pcls_ncdm[i].updateVel(update_q_Newton, (dtau + dtau_old) / 2. / numsteps_ncdm[i], update_ncdm_fields, 1, f_params);
#ifdef BENCHMARK
update_q_count++;
#endif
}
}
#ifdef BENCHMARK
update_q_time += MPI_Wtime() - ref2_time;
ref2_time = MPI_Wtime();
#endif
if (numsteps > 1 && j == numsteps / 2)
{
if (sim.gr_flag > 0)
pcls_cdm.moveParticles(update_pos, dtau, update_cdm_fields, (1. / a < ic.z_relax + 1. ? 3 : 0), f_params);
else
pcls_cdm.moveParticles(update_pos_Newton, dtau, NULL, 0, f_params);
#ifdef BENCHMARK
moveParts_count++;
#endif
}
for (i = 0; i < cosmo.num_ncdm; i++)
{
if (numsteps > 1 && ((numsteps_ncdm[i] == 1 && j == numsteps / 2) || (numsteps_ncdm[i] == numsteps / 2 && j % 2 > 0)))
{
if (sim.gr_flag > 0)
pcls_ncdm[i].moveParticles(update_pos, dtau / numsteps_ncdm[i], update_ncdm_fields, (1. / a < ic.z_relax + 1. ? 3 : 2), f_params);
else
pcls_ncdm[i].moveParticles(update_pos_Newton, dtau / numsteps_ncdm[i], NULL, 0, f_params);
#ifdef BENCHMARK
moveParts_count++;
#endif
}
}
#ifdef BENCHMARK
moveParts_time += MPI_Wtime() - ref2_time;
#endif
rungekutta4bg(a, fourpiG, cosmo, 0.5 * dtau / numsteps); // evolve background by half a time step
#ifdef BENCHMARK
ref2_time = MPI_Wtime();
#endif
f_params[0] = a;
f_params[1] = a * a * sim.numpts;
if (numsteps == 1)
{
if (sim.gr_flag > 0)
pcls_cdm.moveParticles(update_pos, dtau, update_cdm_fields, (1. / a < ic.z_relax + 1. ? 3 : 0), f_params);
else
pcls_cdm.moveParticles(update_pos_Newton, dtau, NULL, 0, f_params);
#ifdef BENCHMARK
moveParts_count++;
#endif
}
for (i = 0; i < cosmo.num_ncdm; i++)
{
if (numsteps_ncdm[i] == numsteps)
{
if (sim.gr_flag > 0)
pcls_ncdm[i].moveParticles(update_pos, dtau / numsteps_ncdm[i], update_ncdm_fields, (1. / a < ic.z_relax + 1. ? 3 : 2), f_params);
else
pcls_ncdm[i].moveParticles(update_pos_Newton, dtau / numsteps_ncdm[i], NULL, 0, f_params);
#ifdef BENCHMARK
moveParts_count++;
#endif
}
}
#ifdef BENCHMARK
moveParts_time += MPI_Wtime() - ref2_time;
#endif
rungekutta4bg(a, fourpiG, cosmo, 0.5 * dtau / numsteps); // evolve background by half a time step
} // particle update done
parallel.max<double>(maxvel);
if (cosmo.num_ncdm > 0) parallel.max<double>(maxvel_ncdm, cosmo.num_ncdm);
if (sim.gr_flag > 0)
{
maxvel /= sqrt(maxvel * maxvel + 1.0);
for (i = 0; i < cosmo.num_ncdm; i++)
maxvel_ncdm[i] /= sqrt(maxvel_ncdm[i] * maxvel_ncdm[i] + 1.0);
}
tau += dtau;
if (tau_Lambda < 0. && (cosmo.Omega_m / a / a / a) < cosmo.Omega_Lambda)
{
tau_Lambda = tau;
COUT << "matter-dark energy equality at z=" << ((1./a) - 1.) << endl;
}
dtau_old = dtau;
if (sim.Cf * dx < sim.steplimit / Hconf(a, fourpiG, cosmo))
dtau = sim.Cf * dx;
else
dtau = sim.steplimit / Hconf(a, fourpiG, cosmo);
cycle++;
#ifdef BENCHMARK
gravity_solver_time += MPI_Wtime() - ref_time;
cycle_time += MPI_Wtime()-cycle_start_time;
#endif
}
COUT << " simulation complete." << endl;
#ifdef BENCHMARK
run_time = MPI_Wtime() - start_time;
parallel.sum(run_time);
parallel.sum(cycle_time);
parallel.sum(projection_time);
parallel.sum(snapshot_output_time);
parallel.sum(spectra_output_time);
parallel.sum(gravity_solver_time);
parallel.sum(fft_time);
parallel.sum(update_q_time);
parallel.sum(moveParts_time);
COUT << endl << "BENCHMARK" << endl;
COUT << "total execution time : "<<hourMinSec(run_time) << endl;
COUT << "total number of cycles: "<< cycle << endl;
COUT << "time consumption breakdown:" << endl;
COUT << "initialization : " << hourMinSec(initialization_time) << " ; " << 100. * initialization_time/run_time <<"%."<<endl;
COUT << "main loop : " << hourMinSec(cycle_time) << " ; " << 100. * cycle_time/run_time <<"%."<<endl;
COUT << "----------- main loop: components -----------"<<endl;
COUT << "projections : "<< hourMinSec(projection_time) << " ; " << 100. * projection_time/cycle_time <<"%."<<endl;
COUT << "snapshot outputs : "<< hourMinSec(snapshot_output_time) << " ; " << 100. * snapshot_output_time/cycle_time <<"%."<<endl;
COUT << "power spectra outputs: "<< hourMinSec(spectra_output_time) << " ; " << 100. * spectra_output_time/cycle_time <<"%."<<endl;
COUT << "gravity solver : "<< hourMinSec(gravity_solver_time) << " ; " << 100. * gravity_solver_time/cycle_time <<"%."<<endl;
COUT << "----------- gravity solver: components ------------"<<endl;
COUT << "Fast Fourier Transforms (count: " << fft_count <<"): "<< hourMinSec(fft_time) << " ; " << 100. * fft_time/gravity_solver_time <<"%."<<endl;
COUT << "update momenta (count: "<<update_q_count <<"): "<< hourMinSec(update_q_time) << " ; " << 100. * update_q_time/gravity_solver_time <<"%."<<endl;
COUT << "move particles (count: "<< moveParts_count <<"): "<< hourMinSec(moveParts_time) << " ; " << 100. * moveParts_time/gravity_solver_time <<"%."<<endl;
#endif
free(kbin);
free(power);
free(kscatter);
free(pscatter);
free(occupation);
#ifdef EXTERNAL_IO
ioserver.stop();
}
#endif
}
static inline void field(double & f, const Field & v, double def = 0.0)
{
f = v.empty() ? def : atof(v.c_str());
}
static inline void field(float & f, const Field & v, float def = 0.0f)
{
f = v.empty() ? def : atof(v.c_str());
}
int main (int argc, char **argv)
{
// ofstream report;
bool pass = true;
static size_t m = 4;
static size_t n = 20;
static size_t nnz = 0;
static integer q = 65521U;
q = 101;
static Argument args[] = {
{ 'm', "-m M", "Set row dimension of test matrix to M.", TYPE_INT, &m },
{ 'n', "-n N", "Set col dimension of test matrix to N.", TYPE_INT, &n },
{ 'z', "-n NNZ", "Set number of nonzero entries in test matrix.", TYPE_INT, &nnz },
{ 'q', "-q Q", "Operate over the \"field\" GF(Q) [1].", TYPE_INTEGER, &q },
END_OF_ARGUMENTS
};
parseArguments (argc, argv, args);
if (nnz == 0) nnz = m*n/10;
srand ((unsigned)time (NULL));
commentator().start("TriplesBB black box test suite", "triplesbb");
//Field
typedef Givaro::Modular<double> Field;
typedef Field::Element Element;
Field F (q);
MatrixDomain<Field> MD(F);
typedef MatrixDomain<Field>::OwnMatrix OwnMatrix;
//Vectors
VectorDomain<Field> VD(F);
BlasVector<Field> x(F,n), y(F,m), z(F,m);
for (size_t i = 0; i < n; ++i) F.init(x[i], i+1);
// TriplesBB<Field> A(F, m, n);
SparseMatrix<Field,SparseMatrixFormat::TPL> A(F, m, n);
randBuild(A, nnz);
pass = pass && testBlackbox(A);
// just see if it compiles
size_t b = 10;
OwnMatrix X(F,n,b), Y(F,m,b), Z(F,b,m), W(F,b,n);
X.random(); Z.random();
A.applyLeft(Y, X);
A.applyRight(W, Z);
// standard constructor
// TriplesBB<Field> B(F, m, n);
SparseMatrix<Field,SparseMatrixFormat::TPL> B(F, m, n);
bidiag(B);
pass = pass && testBlackbox(B);
B.apply(y, x);
// default cstor plus init
// TriplesBB<Field> C(F);
SparseMatrix<Field,SparseMatrixFormat::TPL> C(F);
C.init(F, m, n);
bidiag(C);
pass = pass && testBlackbox(C);
// check B == C
C.apply(z, x);
if (not VD.areEqual(y, z)) {
pass = false;
LinBox::commentator().report() << "fail: cstor and init disagree" << std::endl;
}
// copy construction
// TriplesBB<Field> D(B);
SparseMatrix<Field,SparseMatrixFormat::TPL> D(B);
pass = pass && testBlackbox(D);
// check B == D
D.apply(z, x);
if (not VD.areEqual(y, z)) {
pass = false;
LinBox::commentator().report() << "copy cstor failure" << std::endl;
}
// check that it's deep copy
Element a;
B.getEntry(a,0,0);
F.addin(a, F.one);
D.setEntry(0,0,a);
D.apply(z, x);
if (VD.areEqual(y, z)) {
pass = false;
LinBox::commentator().report() << "fail changed copy cstor and original agree" << std::endl;
VD.write(commentator().report() << "y ", y) << std::endl;
VD.write(commentator().report() << "z ", z) << std::endl;
}
commentator().stop("TriplesBB black box test suite");
return pass ? 0 : -1;
}
void buildVillage(Players_Character player, int* point, Field& f) {
if (f.isNode(point) && f.isInArea(point)) {
Node n(point);
f.appendNode(player, &n);
}
}
static void getFieldTypeName(Field& f, std::string& name)
{
name = getFieldInnerTypeName(f);
if(f.isArray())
name = "List<" + name + ">";
}
TEST(Field, construction)
{
Field field;
EXPECT_EQ(sf::Vector2i(NUM_START_TILE % TILE_NUM_VER, NUM_START_TILE / TILE_NUM_VER), field.getStartTile()->getPosition());
EXPECT_FALSE(field.getTile(NUM_START_TILE)->isPolluted());
EXPECT_EQ(sf::Vector2i(NUM_END_TILE % TILE_NUM_VER, NUM_END_TILE / TILE_NUM_VER), field.getEndTile()->getPosition());
EXPECT_FALSE(field.getTile(NUM_END_TILE)->isPolluted());
std::vector<shared_ptr<Tile>> neighborTiles = field.getTile(sf::Vector2i(TILE_NUM_VER - 1, TILE_NUM_HOR - 1))->getNeighbor(1);
EXPECT_EQ(4, neighborTiles.capacity());
neighborTiles = field.getTile(sf::Vector2i(TILE_NUM_VER - 1, TILE_NUM_HOR - 1))->getNeighbor(1);
EXPECT_EQ(4, neighborTiles.capacity());
neighborTiles = field.getTile(sf::Vector2i(0, TILE_NUM_HOR - 1))->getNeighbor(1);
EXPECT_EQ(4, neighborTiles.capacity());
neighborTiles = field.getTile(sf::Vector2i(TILE_NUM_VER - 1, 0))->getNeighbor(1);
EXPECT_EQ(4, neighborTiles.capacity());
neighborTiles = field.getTile(sf::Vector2i(0, 8))->getNeighbor(1);
EXPECT_EQ(6, neighborTiles.capacity());
neighborTiles = field.getTile(sf::Vector2i(TILE_NUM_VER - 1, 5))->getNeighbor(1);
EXPECT_EQ(6, neighborTiles.capacity());
neighborTiles = field.getTile(sf::Vector2i(3, TILE_NUM_HOR - 1))->getNeighbor(1);
EXPECT_EQ(6, neighborTiles.capacity());
neighborTiles = field.getTile(sf::Vector2i(6, 0))->getNeighbor(1);
EXPECT_EQ(6, neighborTiles.capacity());
neighborTiles = field.getTile(sf::Vector2i(5, 8))->getNeighbor(1);
EXPECT_EQ(9, neighborTiles.capacity());
neighborTiles = field.getTile(sf::Vector2i(7, TILE_NUM_HOR - 1))->getNeighbor(1);
EXPECT_EQ(6, neighborTiles.capacity());
}
forAll (procMeshes_, procI)
{
const GeometricField<Type, fvPatchField, volMesh>& procField =
procFields[procI];
// Set the cell values in the reconstructed field
internalField.rmap
(
procField.internalField(),
cellProcAddressing_[procI]
);
// Set the boundary patch values in the reconstructed field
forAll (boundaryProcAddressing_[procI], patchI)
{
// Get patch index of the original patch
const label curBPatch = boundaryProcAddressing_[procI][patchI];
// Get addressing slice for this patch
const labelList::subList cp =
procMeshes_[procI].boundary()[patchI].patchSlice
(
faceProcAddressing_[procI]
);
// check if the boundary patch is not a processor patch
if (curBPatch >= 0)
{
// Regular patch. Fast looping
if (!patchFields(curBPatch))
{
patchFields.set
(
curBPatch,
fvPatchField<Type>::New
(
procField.boundaryField()[patchI],
mesh_.boundary()[curBPatch],
DimensionedField<Type, volMesh>::null(),
fvPatchFieldReconstructor
(
mesh_.boundary()[curBPatch].size(),
procField.boundaryField()[patchI].size()
)
)
);
}
const label curPatchStart =
mesh_.boundaryMesh()[curBPatch].start();
labelList reverseAddressing(cp.size());
forAll (cp, faceI)
{
// Subtract one to take into account offsets for
// face direction.
reverseAddressing[faceI] = cp[faceI] - 1 - curPatchStart;
}
patchFields[curBPatch].rmap
(
procField.boundaryField()[patchI],
reverseAddressing
);
}
else
{
void PoissonSolver::linearStencil(std::vector<int> & Indices,
std::vector<double> & Values,
double & rhs,
size_t & NumEntries,
const Field<bool, DIM, Mesh_t, Vert> & isInside,
const size_t & gid)
{
const double EW = -1 / (_hr[0]*_hr[0]);
const double NS = -1 / (_hr[1]*_hr[1]);
const int idx = gid % _Nx;
const int idy = gid / _Nx;
const NDIndex<DIM> elem(Index(idx, idx), Index(idy, idy));
if (isInside.localElement(elem)) {
NumEntries = 5;
Values[0] = NS;
Indices[0] = gid - _Nx;
Values[1] = EW;
Indices[1] = gid - 1;
Values[2] = -2 * (EW + NS);
Indices[2] = gid;
Values[3] = EW;
Indices[3] = gid + 1;
Values[4] = NS;
Indices[4] = gid + _Nx;
return;
}
const std::vector<int> & localToBCellNr = _bend.getInverseMapDualGrid();
const int & localID = localToBCellNr[_bend.getLocalID(elem)];
if (localID == -1) {
NumEntries = 1;
Values[0] = 1;
Indices[0] = gid;
NDIndex<DIM> elemmy(elem[0], elem[1] - 1);
int localIDmy = localToBCellNr[_bend.getLocalID(elemmy)];
if (localIDmy != -1 && _boundaryCells[localIDmy].lambda_m(1) > SPACE_EPS) {
const BoundaryCell & bc = _boundaryCells[localIDmy];
const double & s = bc.lambda_m(1);
Values[NumEntries] = (1/s - 1);
Indices[NumEntries] = gid - _Nx;
dbg << gid << " "
<< gid - _Nx << " "
<< Values[NumEntries] << std::endl;
Values[0] = NumEntries;
NumEntries += 1;
}
NDIndex<DIM> elemmx(elem[0] - 1, elem[1]);
int localIDmx = localToBCellNr[_bend.getLocalID(elemmx)];
if (localIDmx != -1 && _boundaryCells[localIDmx].lambda_m(0) > SPACE_EPS) {
const BoundaryCell & bc = _boundaryCells[localIDmx];
const double & s = bc.lambda_m(0);
Values[NumEntries] = (1/s - 1);
Indices[NumEntries] = gid - 1;
dbg << gid << " "
<< gid - 1 << " "
<< Values[NumEntries] << std::endl;
Values[0] = NumEntries;
NumEntries += 1;
}
rhs = 0.0;
return;
}
const BoundaryCell & bc = _boundaryCells[localID];
if (bc.lambda_m[0] > 1 - SPACE_EPS ||
bc.lambda_m[1] > 1 - SPACE_EPS) {
NumEntries = 5;
Values[0] = NS;
Indices[0] = gid - _Nx;
Values[1] = EW;
Indices[1] = gid - 1;
Values[2] = -2 * (EW + NS);
Indices[2] = gid;
Values[3] = EW;
Indices[3] = gid + 1;
Values[4] = NS;
Indices[4] = gid + _Nx;
} else {
NumEntries = 1;
Values[0] = 1;
Indices[0] = gid;
if (bc.lambda_m(0) > SPACE_EPS) {
const double & s = bc.lambda_m(0);
Values[NumEntries] = (1/s - 1);
Indices[NumEntries] = gid + 1;
dbg << gid << " "
<< gid + 1 << " "
<< Values[NumEntries] << std::endl;
Values[0] = NumEntries;
NumEntries += 1;
}
if (bc.lambda_m(1) > SPACE_EPS) {
const double & s = bc.lambda_m(1);
Values[NumEntries] = (1/s - 1);
Indices[NumEntries] = gid + _Nx;
dbg << gid << " "
<< gid + _Nx << " "
<< Values[NumEntries] << std::endl;
Values[0] = NumEntries;
NumEntries += 1;
}
rhs = 0.0;
}
return;
}
Foam::lduMatrix::solverPerformance Foam::fvMatrix<Type>::solve
(
const dictionary& solverControls
)
{
if (debug)
{
Info<< "fvMatrix<Type>::solve(const dictionary&) : "
"solving fvMatrix<Type>"
<< endl;
}
lduSolverPerformance solverPerfVec
(
"fvMatrix<Type>::solve",
psi_.name()
);
scalarField saveDiag = diag();
Field<Type> source = source_;
// At this point include the boundary source from the coupled boundaries.
// This is corrected for the implicit part by updateMatrixInterfaces within
// the component loop.
addBoundarySource(source);
typename Type::labelType validComponents
(
pow
(
psi_.mesh().solutionD(),
pTraits<typename powProduct<Vector<label>, Type::rank>::type>::zero
)
);
// Make a copy of interfaces: no longer a reference
// HJ, 20/Nov/2007
lduInterfaceFieldPtrsList interfaces = psi_.boundaryField().interfaces();
for (direction cmpt = 0; cmpt < Type::nComponents; cmpt++)
{
if (validComponents[cmpt] == -1) continue;
// Copy field and source
scalarField psiCmpt = psi_.internalField().component(cmpt);
addBoundaryDiag(diag(), cmpt);
scalarField sourceCmpt = source.component(cmpt);
FieldField<Field, scalar> bouCoeffsCmpt
(
boundaryCoeffs_.component(cmpt)
);
FieldField<Field, scalar> intCoeffsCmpt
(
internalCoeffs_.component(cmpt)
);
// Use the initMatrixInterfaces and updateMatrixInterfaces to correct
// bouCoeffsCmpt for the explicit part of the coupled boundary
// conditions
initMatrixInterfaces
(
bouCoeffsCmpt,
interfaces,
psiCmpt,
sourceCmpt,
cmpt
);
updateMatrixInterfaces
(
bouCoeffsCmpt,
interfaces,
psiCmpt,
sourceCmpt,
cmpt
);
lduMatrix::solverPerformance solverPerf;
// Solver call
solverPerf = lduMatrix::solver::New
(
psi_.name() + pTraits<Type>::componentNames[cmpt],
*this,
bouCoeffsCmpt,
intCoeffsCmpt,
interfaces,
solverControls
)->solve(psiCmpt, sourceCmpt, cmpt);
solverPerf.print();
if
(
solverPerf.initialResidual() > solverPerfVec.initialResidual()
&& !solverPerf.singular()
)
{
solverPerfVec = solverPerf;
}
psi_.internalField().replace(cmpt, psiCmpt);
diag() = saveDiag;
}
psi_.correctBoundaryConditions();
return solverPerfVec;
}
void PoissonSolver::cutoffStencil(std::vector<int> & Indices,
std::vector<double> & Values,
double & rhs,
size_t & NumEntries,
const Field<bool, DIM, Mesh_t, Cell> & isInside,
const size_t & gid)
{
const double EW = -1 / (_hr[0]*_hr[0]);
const double NS = -1 / (_hr[1]*_hr[1]);
const int idx = gid % _Nx;
const int idy = gid / _Nx;
const NDIndex<DIM> elem(Index(idx, idx), Index(idy, idy));
const NDIndex<DIM> elemmx(elem[0] - 1, elem[1]);
const NDIndex<DIM> elemmy(elem[0], elem[1] - 1);
const NDIndex<DIM> elempx(elem[0] + 1, elem[1]);
const NDIndex<DIM> elempy(elem[0], elem[1] + 1);
const std::vector<int> & localToBCellNr = _bend.getInverseMap();
const int & localID = localToBCellNr[_bend.getLocalID(elem)];
const int & localIDmx = localToBCellNr[_bend.getLocalID(elemmx)];
const int & localIDmy = localToBCellNr[_bend.getLocalID(elemmy)];
const int & localIDpx = localToBCellNr[_bend.getLocalID(elempx)];
const int & localIDpy = localToBCellNr[_bend.getLocalID(elempy)];
long maxX = _bend.getLengthStraightSection();
if (idx < maxX &&
(isInside.localElement(elem) ||
(localID > -1 &&
_boundaryCells[localID].area_m > 0.5))) {
NumEntries = 0;
if (isInside.localElement(elemmy) ||
(localIDmy > -1 &&
_boundaryCells[localIDmy].area_m > 0.5)) {
Indices[NumEntries] = gid - _Nx;
Values[NumEntries] = NS;
NumEntries ++;
}
if (isInside.localElement(elemmx) ||
(localIDmx > -1 &&
_boundaryCells[localIDmx].area_m > 0.5)) {
Indices[NumEntries] = gid - 1;
Values[NumEntries] = EW;
NumEntries ++;
}
if (isInside.localElement(elempx) ||
(localIDpx > -1 &&
_boundaryCells[localIDpx].area_m > 0.5)) {
Indices[NumEntries] = gid + 1;
Values[NumEntries] = EW;
NumEntries ++;
}
if (isInside.localElement(elempy) ||
(localIDpy > -1 &&
_boundaryCells[localIDpy].area_m > 0.5)) {
Indices[NumEntries] = gid + _Nx;
Values[NumEntries] = NS;
NumEntries ++;
}
Indices[NumEntries] = gid;
Values[NumEntries] = -2 * (EW + NS);
NumEntries ++;
return;
}
NumEntries = 1;
Indices[0] = gid;
Values[0] = 1;
rhs = 0;
return;
}
typename Foam::SolverPerformance<Type>
Foam::PCICG<Type, DType, LUType>::solve(Field<Type>& psi) const
{
word preconditionerName(this->controlDict_.lookup("preconditioner"));
// --- Setup class containing solver performance data
SolverPerformance<Type> solverPerf
(
preconditionerName + typeName,
this->fieldName_
);
label nCells = psi.size();
Type* __restrict__ psiPtr = psi.begin();
Field<Type> pA(nCells);
Type* __restrict__ pAPtr = pA.begin();
Field<Type> wA(nCells);
Type* __restrict__ wAPtr = wA.begin();
Type wArA = solverPerf.great_*pTraits<Type>::one;
Type wArAold = wArA;
// --- Calculate A.psi
this->matrix_.Amul(wA, psi);
// --- Calculate initial residual field
Field<Type> rA(this->matrix_.source() - wA);
Type* __restrict__ rAPtr = rA.begin();
// --- Calculate normalisation factor
Type normFactor = this->normFactor(psi, wA, pA);
if (LduMatrix<Type, DType, LUType>::debug >= 2)
{
Info<< " Normalisation factor = " << normFactor << endl;
}
// --- Calculate normalised residual norm
solverPerf.initialResidual() = cmptDivide(gSumCmptMag(rA), normFactor);
solverPerf.finalResidual() = solverPerf.initialResidual();
// --- Check convergence, solve if not converged
if
(
this->minIter_ > 0
|| !solverPerf.checkConvergence(this->tolerance_, this->relTol_)
)
{
// --- Select and construct the preconditioner
autoPtr<typename LduMatrix<Type, DType, LUType>::preconditioner>
preconPtr = LduMatrix<Type, DType, LUType>::preconditioner::New
(
*this,
this->controlDict_
);
// --- Solver iteration
do
{
// --- Store previous wArA
wArAold = wArA;
// --- Precondition residual
preconPtr->precondition(wA, rA);
// --- Update search directions:
wArA = gSumCmptProd(wA, rA);
if (solverPerf.nIterations() == 0)
{
for (label cell=0; cell<nCells; cell++)
{
pAPtr[cell] = wAPtr[cell];
}
}
else
{
Type beta = cmptDivide
(
wArA,
stabilise(wArAold, solverPerf.vsmall_)
);
for (label cell=0; cell<nCells; cell++)
{
pAPtr[cell] = wAPtr[cell] + cmptMultiply(beta, pAPtr[cell]);
}
}
// --- Update preconditioned residual
this->matrix_.Amul(wA, pA);
Type wApA = gSumCmptProd(wA, pA);
// --- Test for singularity
if
(
solverPerf.checkSingularity
(
cmptDivide(cmptMag(wApA), normFactor)
)
)
{
break;
}
// --- Update solution and residual:
Type alpha = cmptDivide
(
wArA,
stabilise(wApA, solverPerf.vsmall_)
);
for (label cell=0; cell<nCells; cell++)
{
psiPtr[cell] += cmptMultiply(alpha, pAPtr[cell]);
rAPtr[cell] -= cmptMultiply(alpha, wAPtr[cell]);
}
solverPerf.finalResidual() =
cmptDivide(gSumCmptMag(rA), normFactor);
} while
(
(
solverPerf.nIterations()++ < this->maxIter_
&& !solverPerf.checkConvergence(this->tolerance_, this->relTol_)
)
|| solverPerf.nIterations() < this->minIter_
);
}
return solverPerf;
}
virtual int onNext(const Field &f)
{
EXPECT_EQ(f.type(), Field::COMPOSITE);
EXPECT_EQ(f.fieldName(), "");
EXPECT_EQ(f.compositeName(), "messageHeader");
EXPECT_EQ(f.schemaId(), Field::INVALID_ID);
EXPECT_EQ(f.numEncodings(), 4);
EXPECT_EQ(f.encodingName(0), "blockLength");
EXPECT_EQ(f.encodingName(1), "templateId");
EXPECT_EQ(f.encodingName(2), "version");
EXPECT_EQ(f.encodingName(3), "reserved");
EXPECT_EQ(f.primitiveType(0), Ir::UINT16);
EXPECT_EQ(f.primitiveType(1), Ir::UINT16);
EXPECT_EQ(f.primitiveType(2), Ir::UINT8);
EXPECT_EQ(f.primitiveType(3), Ir::UINT8);
EXPECT_EQ(f.getUInt(0), BLOCKLENGTH);
EXPECT_EQ(f.getUInt(1), TEMPLATE_ID);
EXPECT_EQ(f.getUInt(2), VERSION);
EXPECT_EQ(f.getUInt(3), 0u);
numFieldsSeen_++;
return 0;
};
void Node::cloneFieldValue ( Field& _from, Field& _to, bool deepCopy, DeepCopyMap& deepCopyMap ) {
// Only copy INPUT_OUTPUT and INITIALIZE_ONLY
if ( _from.getAccessType() == Field::INPUT_OUTPUT || _from.getAccessType() == Field::INITIALIZE_ONLY ) {
// MField types
if( MFieldClass *mfield_from = dynamic_cast< MFieldClass * >( &_from ) ) {
// MFNode
if( MFNode *mfnode_from = dynamic_cast< MFNode * >( &_from ) ) {
if ( MFNode *mfnode_to = dynamic_cast< MFNode * >( &_to ) ) {
NodeVector src= mfnode_from->getValue();
for ( size_t j= 0; j < src.size(); ++j ) {
src.set ( j, getClonedInstance ( src[j], deepCopy, deepCopyMap ) );
}
mfnode_to->setValue ( src );
}
// MFString
} else if ( MFString *mfstring_from = dynamic_cast< MFString * > ( &_from ) ) {
// MFString does not work with getValueAsVoidPtr. Do special case or fix getValueAsVoidPtr.
if ( MFString *mfstring_to = dynamic_cast< MFString * >( &_to ) ) {
if ( !mfstring_from->getValueAsString().empty() ){
// avoid setting value when not actaully needed
mfstring_to->setValue ( mfstring_from->getValue ( ) );
}
}
// Generic MField
} else {
if ( MFieldClass *mfield_to = dynamic_cast< MFieldClass * >( &_to ) ) {
unsigned int data_size = mfield_from->valueTypeSize() * mfield_from->size();
unsigned int nr_elements;
unsigned char* data = new unsigned char[ data_size ];
int result = mfield_from->getValueAsVoidPtr( data, nr_elements, data_size );
if ( result != -1 ) {
mfield_to->setValueFromVoidPtr ( (const void*) data, nr_elements, data_size );
}
delete [] data;
}
}
// SField types
} else if( SFieldClass *sfield_from = dynamic_cast< SFieldClass * >( &_from ) ) {
// SFString
if( SFString *sfstring_from = dynamic_cast< SFString * > ( &_from ) ) {
// the getValueAsVoidPtr function does not work well with
// SFString fields so do a special case for that type.
if ( SFString *sfstring_to = dynamic_cast< SFString * >( &_to ) ) {
if ( !sfstring_from->getValue().empty() ){
// avoid setValue for sfstring_to when not really needed
sfstring_to->setValue ( sfstring_from->getValue ( ) );
}
}
// Generic SField
} else {
if ( SFieldClass *sfield_to = dynamic_cast< SFieldClass * >( &_to ) ) {
unsigned int data_size = sfield_from->valueTypeSize();
unsigned char* data = new unsigned char[ data_size ];
data_size = sfield_from->getValueAsVoidPtr( data, data_size );
if ( data_size != -1 ) {
sfield_to->setValueFromVoidPtr ( (const void *)data, data_size );
}
delete [] data;
}
}
// SFNode
} else if( SFNode *sfnode_from = dynamic_cast< SFNode * >( &_from ) ) {
if ( SFNode *sfnode_to = dynamic_cast< SFNode * >( &_to ) ) {
Node* n= getClonedInstance ( sfnode_from->getValue(), deepCopy, deepCopyMap );
sfnode_to->setValue ( n );
}
}
}
}
bool check_ftrsm (const Field &F, size_t m, size_t n, const typename Field::Element &alpha, FFLAS::FFLAS_SIDE side, FFLAS::FFLAS_UPLO uplo, FFLAS::FFLAS_TRANSPOSE trans, FFLAS::FFLAS_DIAG diag, RandIter& Rand){
typedef typename Field::Element Element;
Element * A, *B, *B2, *C, tmp;
size_t k = (side==FFLAS::FflasLeft?m:n);
size_t lda,ldb,ldc;
lda=k+13;
ldb=n+14;
ldc=n+15;
A = FFLAS::fflas_new(F,k,lda);
B = FFLAS::fflas_new(F,m,ldb);
B2 = FFLAS::fflas_new(F,m,ldb);
C = FFLAS::fflas_new(F,m,ldc);
RandomTriangularMatrix (F, k, k, uplo, diag, true, A, lda, Rand);
RandomMatrix (F, m, n, B, ldb, Rand);
FFLAS::fassign (F, m, n, B, ldb, B2, ldb);
string ss=string((uplo == FFLAS::FflasLower)?"Lower_":"Upper_")+string((side == FFLAS::FflasLeft)?"Left_":"Right_")+string((trans == FFLAS::FflasTrans)?"Trans_":"NoTrans_")+string((diag == FFLAS::FflasUnit)?"Unit":"NonUnit");
cout<<std::left<<"Checking FTRSM_";
cout.fill('.');
cout.width(35);
cout<<ss;
FFLAS::Timer t; t.clear();
double time=0.0;
t.clear();
t.start();
FFLAS::ftrsm (F, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb);
t.stop();
time+=t.usertime();
Element invalpha;
F.init(invalpha);
F.inv(invalpha, alpha);
//FFLAS::ftrmm (F, side, uplo, trans, diag, m, n, invalpha, A, k, B, n);
if (side == FFLAS::FflasLeft)
FFLAS::fgemm(F, trans, FFLAS::FflasNoTrans, m, n, m, invalpha, A, lda, B, ldb, F.zero, C, ldc);
else
FFLAS::fgemm(F, FFLAS::FflasNoTrans, trans, m, n, n, invalpha, B, ldb, A, lda, F.zero, C, ldc);
bool ok = true;
if (FFLAS::fequal (F, m, n, B2, ldb, C, ldc)){
//cout << "\033[1;32mPASSED\033[0m ("<<time<<")"<<endl;
cout << "PASSED ("<<time<<")"<<endl;
//cerr<<"PASSED ("<<time<<")"<<endl;
} else{
//cout << "\033[1;31mFAILED\033[0m ("<<time<<")"<<endl;
cout << "FAILED ("<<time<<")"<<endl;
ok=false;
//cerr<<"FAILED ("<<time<<")"<<endl;
}
F.mulin(invalpha,alpha);
if (!F.isOne(invalpha)){
cerr<<"invalpha is wrong !!!"<<endl;;
}
FFLAS::fflas_delete(A);
FFLAS::fflas_delete(B);
FFLAS::fflas_delete(B2);
FFLAS::fflas_delete(C);
return ok;
}
int destroyElementsConditional(Field& conditionalField)
{
return Cmiss_mesh_destroy_elements_conditional(id,
conditionalField.getId());
}
void Node::outputXMLField(std::ostream& ps, Field *field, int indentLevel, bool isSingleLine) const
{
char *indentString = getIndentLevelString(indentLevel+1);
const char *fieldName = field->getName();
char *spaceString = getSpaceString(StringLength(fieldName)+2);
if (hasOutputXMLField(field) == false) {
delete [] indentString;
delete [] spaceString;
return;
}
if (isSingleLine == true)
ps << " ";
else
ps << std::endl;
if (field->isSField() == true) {
if (isSingleLine == false)
ps << indentString;
if (field->toXMLString ())
ps << fieldName << "=\"" << field->toXMLString() << "\"";
delete [] indentString;
delete [] spaceString;
return;
}
if (field->isMField() == true) {
MField *mfield = (MField *)field;
int fieldSize = mfield->getSize();
if (fieldSize == 0) {
ps << indentString << fieldName << "=\"" << "\"";
delete [] indentString;
delete [] spaceString;
return;
}
if (fieldSize == 1) {
Field *eleField = (Field*)mfield->getObject(0);
string eleString = eleField->toXMLString();
ps << indentString << fieldName << "=\"" << eleString.c_str() << "\"";
delete [] indentString;
delete [] spaceString;
return;
}
for (int n=0; n<fieldSize; n++) {
if (n==0)
ps << indentString << fieldName << "=\"";
ps << indentString << spaceString;
Field *eleField = (Field*)mfield->getObject(n);
string eleString = eleField->toXMLString();
ps << eleString;
if (n < (fieldSize-1)) {
ps << std::endl;
/*
if (mfield->isSingleValueMField() == true)
ps << std::endl;
else
ps << "," << std::endl;
*/
}
else
ps << "\"";
}
delete [] indentString;
delete [] spaceString;
return;
}
delete []indentString;
delete []spaceString;
}
void GrbSource::get(Field& x) {
int n = d_so.getNumber();
x.assign(n);
d_eoi = d_so.eof();
};
int AI::thinkWrapperEX(Field self, Field enemy)
{
Time.reset();
stop = false;
calls_count = 0;
int timeLimit = 999999;
// 静かな局面になるまで局面を進める
int my_remain_time = enemy.generateStaticState(self);
// enemyが死んでいる局面の場合は-1が返ってくる
if (my_remain_time == -1)
{
if (enemy.isDeath())
{
operate_.clear();
// その時は探索は行わず、ずっと回転し続けることにする（煽りではない）
for (int i = 0; i < 1000; i++)
{
if (i % 7 == 0)
operate_.push(R_ROTATE);
else
operate_.push(0);
}
return 0;
}
}
// 進めたことによりエラーが発生しないかどうか。
assert(self.examine());
assert(enemy.examine());
// 探索用に小さなサイズのフィールドにする
LightField s(self);
LightField e(enemy);
assert(s.chainMax() == 0 && e.chainMax() == 0);
assert(s.examine());
assert(e.examine());
ChainsList* c1 = new ChainsList(100);
ChainsList* c2 = new ChainsList(100);
s.setChains(c1);
e.setChains(c2);
// 世代を進める
TT.newSearch();
Score alpha = -SCORE_INFINITE; // α:下限値
Score beta = SCORE_INFINITE; // β:上限値
Score delta = alpha;
Score score = SCORE_ZERO;
continue_self_num_ = 0;
Move best_move;
Move mlist[22];
int mcount = s.generateMoves(mlist);
// 死んでいる局面ではないはず
assert(mcount > 0);
root_moves.clear();
for (int i = 0; i < mcount; ++i)
{
root_moves.push_back(Search::RootMove(mlist[i]));
root_moves[i].player.push_back(self.player());
}
// 反復深化
for (Depth d = ONE_PLY; d <= depth_max_; ++d)
{
if (stop)
break;
MyOutputDebugString("depth = %d, stop = %d\n", d, stop);
// 前回のiterationでの指し手の点数をすべてコピー
for (int i = 0; i < root_moves.size(); ++i)
root_moves[i].previous_score = root_moves[i].score;
#if 0
// aspiration search
// alpha betaをある程度絞ることで、探索効率を上げる。
if (3 <= depth_max_ && abs(root_moves[0].previous_score) < SCORE_INFINITE)
{
delta = static_cast<Score>(5);
alpha = static_cast<Score>(root_moves[0].previous_score) - delta;
beta = static_cast<Score>(root_moves[0].previous_score) + delta;
}
else
#endif
{
alpha = -SCORE_INFINITE;
beta = SCORE_INFINITE;
}
// aspiration search のwindow幅をはじめは小さい値にして探索し、
// fail high/lowになったなら、今度はwindow幅を広げて再探索を行う。
while (true)
{
// 探索開始
score = search<ROOT>(alpha, beta, s, e, d, my_remain_time);
// 先頭が最善手になるようにソート
insertionSort(root_moves.begin(), root_moves.end());
// fail high / lowが起きなかった場合はループを抜ける。
if (alpha < score && score < beta)
break;
// fail low/highが起きた場合、aspiration窓を増加させ再探索し、
// さもなくばループを抜ける。
if (abs(score) >= Score(10000))
{
// 勝ちか負けだと判定したら、最大の幅で探索を試してみる。
alpha = -SCORE_INFINITE;
beta = SCORE_INFINITE;
}
else if (beta <= score)
{
beta += delta;
delta += delta / 2;
}
else
{
alpha -= delta;
delta += delta / 2;
}
if (stop)
break;
}
best_move = stop ? best_move : best_[d];
MyOutputDebugString("score = %d, depth = %d, best = %s", score, depth_max_, best_move.toString(self, 0));
int s_field_ply = 0;
int e_field_ply = 0;
// pv表示
for (int size = 0; size < root_moves[0].pv.size() - 1; size++)
{
LightField* now_player = root_moves[0].player[size] == self.player() ? &self : &enemy;
int now_field_ply;
if (now_player == &self)
now_field_ply = s_field_ply++;
else
now_field_ply = e_field_ply++;
MyOutputDebugString("%s%s,",
root_moves[0].player[size] == PLAYER1 ? "P1:" : "P2:",
root_moves[0].pv[size].toString(*now_player, now_field_ply).c_str());
}
MyOutputDebugString("\n");
}
MyOutputDebugString("\n");
// 探索した結果得られた手を実際に配置できるかどうか。
assert(self.isEmpty(best_move.psq()) && self.isEmpty(best_move.csq()));
// best_moveを操作に変換
operate_.generate(best_move, self);
delete c1;
delete c2;
return score;
}
