static void configure_amba_stbus_type2(struct stm_amba_bridge *plug,
const struct stm_amba_bridge_config *config)
{
u32 chunks_in_msg = ob2(config->chunks_in_msg, 31);
u32 packets_in_chunk = ob2(config->packets_in_chunk, 31);
u32 threshold = ob2(config->type2.threshold, 15);
u32 value;
if (!plug->config->type2.sd_config_missing) {
/* Set up SD_CONFIG */
value = (config->type2.req_notify <<
SD_CONFIG_REQ_NOTIFY_SHIFT) |
(config->type2.cont_on_error <<
SD_CONFIG_CONT_ON_ERROR_SHIFT) |
(config->type2.msg_merge <<
SD_CONFIG_STBUS_MESSAGE_MERGER_SHIFT);
writel(value, plug->base + SD_CONFIG);
}
value = (threshold << AD_CONFIG_THRESHOLD_SHIFT) |
(chunks_in_msg << AD_CONFIG_CHUNKS_IN_MSG_SHIFT) |
(packets_in_chunk << AD_CONFIG_PCKS_IN_CHUNK_SHIFT) |
(config->type2.trigger_mode << AD_CONFIG_TRIGGER_MODE_SHIFT) |
(config->write_posting << AD_CONFIG_POSTED_SHIFT) |
((config->max_opcode + 2) << AD_CONFIG_OPCODE_SHIFT) |
(config->type2.read_ahead << AD_CONFIG_READ_AHEAD_SHIFT);
writel(value, plug->base + AD_CONFIG);
}
static void configure_amba_stbus_type1(struct stm_amba_bridge *plug,
const struct stm_amba_bridge_config *config)
{
u32 chunks_in_msg = ob2(config->chunks_in_msg, 6);
u32 packets_in_chunk = ob2(config->packets_in_chunk, 6);
writel(config->max_opcode | (config->write_posting << 4),
plug->base + AHB2STBUS_STBUS_OPC);
writel(chunks_in_msg, plug->base + AHB2STBUS_MSGSIZE);
writel(packets_in_chunk, plug->base + AHB2STBUS_CHUNKSIZE);
writel(config->type1.req_timeout, plug->base + AHB2STBUS_REQ_TIMEOUT);
}
int main(){
Plorg ob1; //default initialization
ob1.showContents();
Plorg ob2("The klingonian");
ob2.showContents();
ob2.resetCI(15);
ob2.showContents();
return 0;
}
/************************************************ Program 3 Continued.... **************************************************/
void prog3()
{
loc ob1(10, 20), ob2(5, 30), ob3(90, 90);
ob1.show();
ob2.show();
++ob1;
ob1.show(); // displays 11 21
ob2 = ++ob1;
ob1.show(); // displays 12 22
ob2.show(); // displays 12 22
ob1 = ob2 = ob3; // multiple assignment
ob1.show(); // displays 90 90
ob2.show(); // displays 90 90
}
bool Character::start_script( Bscript::EScriptProgram* prog,
bool start_attached,
Bscript::BObjectImp* param2,
Bscript::BObjectImp* param3,
Bscript::BObjectImp* param4 )
{
if ( !( !start_attached || ( script_ex == NULL ) ) )
{
POLLOG << "Character::start_script hiccup\n"
<< "Trying to start script " << prog->name.get() << "\n"
<< "Script " << script_ex->scriptname() << " is already running\n";
return false; // if it's going to have a passert() error, just return false.
}
passert( !start_attached || ( script_ex == NULL ) );
Bscript::BObject ob2( param2 ? param2 : Bscript::UninitObject::create() );
Bscript::BObject ob3( param3 ? param3 : Bscript::UninitObject::create() );
Bscript::BObject ob4( param4 ? param4 : Bscript::UninitObject::create() );
std::unique_ptr<Core::UOExecutor> ex( Core::create_script_executor() );
auto uoemod = new Module::UOExecutorModule( *ex );
ex->addModule( uoemod );
if ( prog->haveProgram )
{
if ( param4 ) ex->pushArg( param4 );
if ( param3 ) ex->pushArg( param3 );
if ( param2 ) ex->pushArg( param2 );
ex->pushArg( new Module::ECharacterRefObjImp( this ) );
}
ex->os_module->priority = 100;
if ( ex->setProgram( prog ) )
{
if ( start_attached )
{
script_ex = ex.get();
uoemod->attached_chr_ = this;
}
uoemod->controller_.set( this );
schedule_executor( ex.release() );
return true;
}
else
{
POLLOG << "Unable to setProgram(" << prog->name.get() << ")\n";
return false;
}
}
void prog2()
{
int abcd;
loc ob1(10, 20), ob2(5, 30);
ob1.show(); // displays 10 20
ob2.show(); // displays 5 30
//ob1 =
// abcd = ob1 + ;
//ob1 =
abcd = ob1.operator+();
ob1++;
++ob1;
ob1.show(); // displays 15 50
}
//------------------------------------------------------------------------------
int main( int argc, char * argv[] )
{
base::auxi::Timer total, detailed;
//--------------------------------------------------------------------------
// User input
if ( argc != 5 ) {
std::cout << "Usage: " << argv[0]
<< " file.smf radius E1 E2 \n\n";
return -1;
}
// input mesh file
const std::string smfFile = boost::lexical_cast<std::string>( argv[1] );
const std::string baseName = base::io::baseName( smfFile, ".smf" );
// problem parameter
const double radius = boost::lexical_cast<double>( argv[2] );
const double E1 = boost::lexical_cast<double>( argv[3] );
const double E2 = boost::lexical_cast<double>( argv[4] );
const double penaltyFactor = 20.0;
// material stuff
const double nu = 0.3;
const double lambda1 = mat::Lame::lambda( E1, nu );
const double lambda2 = mat::Lame::lambda( E2, nu );
const double mu1 = mat::Lame::mu( E1, nu );
const double mu2 = mat::Lame::mu( E2, nu );
//--------------------------------------------------------------------------
const unsigned geomDeg = 1;
const unsigned dim = SPACEDIM;
const base::Shape shape = base::SimplexShape<dim>::value;
const bool isSigned = true;
const unsigned fieldDeg = 1;
const unsigned doFSize = dim;
// use Nitsche
const bool useNitscheTerms = true;
//--------------------------------------------------------------------------
// Domain mesh
typedef base::Unstructured<shape,geomDeg> Mesh;
Mesh mesh;
{
std::ifstream smf( smfFile.c_str() );
base::io::smf::readMesh( smf, mesh );
}
//--------------------------------------------------------------------------
// Compute the level set data
typedef base::cut::LevelSet<dim> LevelSet;
std::vector<LevelSet> levelSet;
base::cut::AnalyticSurface<dim>::Type as =
boost::bind( &interface<dim>, _1, radius, _2 );
base::cut::analyticLevelSet( mesh, as, isSigned, levelSet );
//--------------------------------------------------------------------------
// FE
typedef base::fe::Basis<shape,fieldDeg> FEBasis;
typedef base::cut::ScaledField<FEBasis,doFSize> Field;
Field fieldIn, fieldOut;
base::dof::generate<FEBasis>( mesh, fieldIn );
base::dof::generate<FEBasis>( mesh, fieldOut );
//--------------------------------------------------------------------------
// Cut
typedef base::cut::Cell<shape> Cell;
std::vector<Cell> cells;
base::cut::generateCutCells( mesh, levelSet, cells );
//--------------------------------------------------------------------------
// surface meshes
typedef base::cut::SurfaceMeshBinder<Mesh>::SurfaceMesh SurfaceMesh;
SurfaceMesh boundaryMesh, interfaceMesh;
// from boundary
{
// identify list of element boundary faces
base::mesh::MeshBoundary meshBoundary;
meshBoundary.create( mesh.elementsBegin(), mesh.elementsEnd() );
// generate a mesh from that list (with a filter)
base::mesh::generateBoundaryMesh( meshBoundary.begin(),
meshBoundary.end(),
mesh, boundaryMesh,
boost::bind( &dirichletBoundary<dim>, _1 ) );
}
// from interface
base::cut::generateSurfaceMesh<Mesh,Cell>( mesh, cells, interfaceMesh );
//--------------------------------------------------------------------------
// Quadratures
const unsigned kernelDegEstimate = 5;
// for domain
typedef base::cut::Quadrature<kernelDegEstimate,shape> CutQuadrature;
CutQuadrature cutQuadratureIn( cells, true );
CutQuadrature cutQuadratureOut( cells, false );
// for surface
typedef base::SurfaceQuadrature<kernelDegEstimate,shape> SurfaceQuadrature;
SurfaceQuadrature surfaceQuadrature;
//--------------------------------------------------------------------------
// Bind fields
// for domain fields
typedef base::asmb::FieldBinder<Mesh,Field,Field> FieldBinder;
typedef FieldBinder::TupleBinder<1,1>::Type FTB1;
typedef FieldBinder::TupleBinder<2,2>::Type FTB2;
FieldBinder fieldBinder( mesh, fieldIn, fieldOut );
// for surface fields
typedef base::asmb::SurfaceFieldBinder<SurfaceMesh,Field,Field> SurfaceFieldBinder;
typedef SurfaceFieldBinder::TupleBinder<1,1>::Type STB11;
typedef SurfaceFieldBinder::TupleBinder<2,2>::Type STB22;
typedef SurfaceFieldBinder::TupleBinder<1,2>::Type STB12;
typedef SurfaceFieldBinder::TupleBinder<2,1>::Type STB21;
SurfaceFieldBinder boundaryFieldBinder( boundaryMesh, fieldIn, fieldOut );
SurfaceFieldBinder interfaceFieldBinder( interfaceMesh, fieldIn, fieldOut );
// compute supports, scale basis
const std::size_t numDoFs = std::distance( fieldIn.doFsBegin(), fieldIn.doFsEnd() );
std::vector<double> supportsIn, supportsOut;
supportsIn.resize( numDoFs );
supportsOut.resize( numDoFs );
base::cut::supportComputation( mesh, fieldIn, cutQuadratureIn, supportsIn );
base::cut::supportComputation( mesh, fieldOut, cutQuadratureOut, supportsOut );
fieldIn.scaleAndTagBasis( supportsIn, 1.e-10 );
fieldOut.scaleAndTagBasis( supportsOut, 1.e-10 );
//fieldIn.tagBasis( supportsIn, 1.e-10 );
//fieldOut.tagBasis( supportsOut, 1.e-10 );
// number DoFs, create solver
const std::size_t activeDoFsIn =
base::dof::numberDoFsConsecutively( fieldIn.doFsBegin(), fieldIn.doFsEnd() );
const std::size_t activeDoFsOut =
base::dof::numberDoFsConsecutively( fieldOut.doFsBegin(),
fieldOut.doFsEnd(), activeDoFsIn );
typedef base::solver::Eigen3 Solver;
Solver solver( activeDoFsIn + activeDoFsOut );
message( "Preprocessing time = " + detailed.print() );
detailed.reset();
//--------------------------------------------------------------------------
// Stiffness matrix
typedef mat::hypel::StVenant Material;
Material material1( lambda1, mu1 );
Material material2( lambda2, mu2 );
// matrix kernel
typedef solid::HyperElastic<Material,FTB1::Tuple> HyperElastic1;
HyperElastic1 hyperElastic1( material1 );
typedef solid::HyperElastic<Material,FTB2::Tuple> HyperElastic2;
HyperElastic2 hyperElastic2( material2 );
message( "Stiffness" );
base::asmb::stiffnessMatrixComputation<FTB1>( cutQuadratureIn, solver,
fieldBinder, hyperElastic1 );
base::asmb::stiffnessMatrixComputation<FTB2>( cutQuadratureOut, solver,
fieldBinder, hyperElastic2 );
// boundary conditions
#if 1
{
message("Boundary Penalty");
base::nitsche::OuterBoundary ob1( E1);
base::nitsche::OuterBoundary ob2( E2);
base::nitsche::penaltyLHS<STB11>( surfaceQuadrature, solver,
boundaryFieldBinder, ob1, penaltyFactor );
base::nitsche::penaltyLHS<STB22>( surfaceQuadrature, solver,
boundaryFieldBinder, ob2, penaltyFactor );
base::nitsche::penaltyRHS<STB11>( surfaceQuadrature, solver, boundaryFieldBinder,
boost::bind( &dirichlet<dim>, _1), ob1,
penaltyFactor );
base::nitsche::penaltyRHS<STB22>( surfaceQuadrature, solver, boundaryFieldBinder,
boost::bind( &dirichlet<dim>, _1), ob2,
penaltyFactor );
if ( useNitscheTerms ) {
message("Boundary Nitsche");
base::nitsche::energyLHS<STB11>( hyperElastic1, surfaceQuadrature, solver,
boundaryFieldBinder, ob1 );
base::nitsche::energyLHS<STB22>( hyperElastic2, surfaceQuadrature, solver,
boundaryFieldBinder, ob2 );
base::nitsche::energyRHS<STB11>( hyperElastic1, surfaceQuadrature, solver,
boundaryFieldBinder,
boost::bind( &dirichlet<dim>, _1), ob1 );
base::nitsche::energyRHS<STB22>( hyperElastic2, surfaceQuadrature, solver,
boundaryFieldBinder,
boost::bind( &dirichlet<dim>, _1), ob2 );
}
}
// interface conditions
{
message("Interface Penalty");
base::nitsche::ImmersedInterface<Cell> ip( E1, E2, cells );
base::nitsche::penaltyLHS<STB11>( surfaceQuadrature, solver,
interfaceFieldBinder, ip, penaltyFactor );
base::nitsche::penaltyLHS<STB22>( surfaceQuadrature, solver,
interfaceFieldBinder, ip, penaltyFactor );
base::nitsche::penaltyLHS<STB12>( surfaceQuadrature, solver, interfaceFieldBinder,
ip, -penaltyFactor );
base::nitsche::penaltyLHS<STB21>( surfaceQuadrature, solver, interfaceFieldBinder,
ip, -penaltyFactor );
if ( useNitscheTerms ) {
message("Interface Nitsche");
base::nitsche::energyLHS<STB11>(
hyperElastic1, surfaceQuadrature, solver,
interfaceFieldBinder, ip, true, true ); // kappa1
base::nitsche::energyLHS<STB21>(
hyperElastic1, surfaceQuadrature, solver,
interfaceFieldBinder, ip, true, false ); // -kappa1
base::nitsche::energyLHS<STB12>(
hyperElastic2, surfaceQuadrature, solver,
interfaceFieldBinder, ip, false, true ); // kappa2
base::nitsche::energyLHS<STB22>(
hyperElastic2, surfaceQuadrature, solver,
interfaceFieldBinder, ip, false, false ); // -kappa2
}
}
#endif
//--------------------------------------------------------------------------
// Solve and distribute
solver.finishAssembly();
message( "Assembly time = " + detailed.print() );
detailed.reset();
#ifdef VERBOSE
{
solver.systemInfo( std::cout );
std::ofstream mat( "matrix" );
solver.debugLHS( mat );
std::ofstream vec( "vector" );
solver.debugRHS( vec );
}
#endif
#if 1 // decide to solve and post-process
//solver.choleskySolve();
const unsigned numCGIter = solver.cgSolve();
//message( "Solve time = " + detailed.print() );
const double solveTime = detailed.seconds();
detailed.reset();
base::dof::setDoFsFromSolver( solver, fieldIn );
base::dof::setDoFsFromSolver( solver, fieldOut );
//--------------------------------------------------------------------------
// Extract distances, closestPoints and location flags from level set data
{
}
//--------------------------------------------------------------------------
{
const std::string vtkFile = baseName + ".vtk";
std::ofstream vtk( vtkFile.c_str() );
base::io::vtk::LegacyWriter vtkWriter( vtk );
vtkWriter.writeUnstructuredGrid( mesh );
{
std::vector<double> distances;
std::transform( levelSet.begin(), levelSet.end(),
std::back_inserter( distances ),
boost::bind( &LevelSet::getSignedDistance, _1 ) );
vtkWriter.writePointData( distances.begin(), distances.end(), "distances" );
}
{
std::vector<bool> location;
std::transform( levelSet.begin(), levelSet.end(),
std::back_inserter( location ),
boost::bind( &LevelSet::isInterior, _1 ) );
vtkWriter.writePointData( location.begin(), location.end(), "location" );
}
vtkWriter.writePointData( supportsIn.begin(), supportsIn.end(), "suppIn" );
vtkWriter.writePointData( supportsOut.begin(), supportsOut.end(), "suppOut" );
base::io::vtk::writePointData( vtkWriter, mesh, fieldIn, "fieldIn" );
base::io::vtk::writePointData( vtkWriter, mesh, fieldOut, "fieldOut" );
vtk.close();
}
#ifdef VERBOSE // decide error verbosity
// integrate
double volumeIn = 0.;
base::asmb::simplyIntegrate<FTB1>( cutQuadratureIn, volumeIn, fieldBinder,
base::kernel::Measure<FTB1::Tuple>() );
double volumeOut = 0.;
base::asmb::simplyIntegrate<FTB2>( cutQuadratureOut, volumeOut, fieldBinder,
base::kernel::Measure<FTB2::Tuple>() );
std::cout << "Volume of mesh: " << volumeIn << " + " << volumeOut
<< " = " << volumeIn + volumeOut
<< '\n';
#else
// for convergence analysis
std::cout << solveTime << " " << numCGIter << "\n";
#endif
#endif // decide to solve and write
message( "Post-process time = " + detailed.print() );
message( "---------------------------------------" );
message( "Total time = " + total.print() );
return 0;
}
void prog2()
{
date ob1(12, 4, 2011), ob2("10/22/2001");
ob1.show_date();
ob2.show_date();
}
