void
BoolValidatorDependencyXMLConverter::convertSpecialValidatorAttributes(
RCP<const ValidatorDependency> dependency,
XMLObject& xmlObj,
ValidatortoIDMap& validatorIDsMap) const
{
RCP<const BoolValidatorDependency> castedDependency =
rcp_dynamic_cast<const BoolValidatorDependency>(dependency, true);
RCP<const ParameterEntryValidator> trueVali =
castedDependency->getTrueValidator();
RCP<const ParameterEntryValidator> falseVali =
castedDependency->getFalseValidator();
if(nonnull(trueVali)){
if(validatorIDsMap.find(castedDependency->getTrueValidator()) ==
validatorIDsMap.end()){
validatorIDsMap.insert(castedDependency->getTrueValidator());
}
xmlObj.addAttribute(
getTrueValidatorIdAttributeName(),
validatorIDsMap.find(castedDependency->getTrueValidator())->second);
}
if(nonnull(falseVali)){
if(validatorIDsMap.find(falseVali) ==
validatorIDsMap.end()){
validatorIDsMap.insert(falseVali);
}
xmlObj.addAttribute(
getFalseValidatorIdAttributeName(),
validatorIDsMap.find(falseVali)->second);
}
}
void TpetraVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>::initializeImpl(
const RCP<const TpetraVectorSpace<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraVectorSpace,
const RCP<TpetraVector_t> &tpetraVector
)
{
#ifdef TEUCHOS_DEBUG
TEUCHOS_ASSERT(nonnull(tpetraVectorSpace));
TEUCHOS_ASSERT(nonnull(tpetraVector));
#endif
tpetraVectorSpace_ = tpetraVectorSpace;
tpetraVector_.initialize(tpetraVector);
this->updateSpmdSpace();
}
Teuchos::RCP<panzer::BCStrategy_TemplateManager<panzer::Traits> >
BCFactoryComposite::
buildBCStrategy(const panzer::BC& bc,
const Teuchos::RCP<panzer::GlobalData>& global_data) const
{
Teuchos::RCP<panzer::BCStrategy_TemplateManager<panzer::Traits> > bcs_tm;
bool found = false;
for (std::vector<Teuchos::RCP<panzer::BCStrategyFactory> >::const_iterator factory = m_bc_strategy_factories.begin();
factory != m_bc_strategy_factories.end(); ++factory) {
bcs_tm = (*factory)->buildBCStrategy(bc,global_data);
if (nonnull(bcs_tm)) {
found = true;
break;
}
}
TEUCHOS_TEST_FOR_EXCEPTION(!found, std::logic_error,
"Error - the BC Strategy called \"" << bc.strategy() <<
"\" is not a valid identifier in the BCStrategyFactory. Either add " <<
"a valid implementation to the factory or fix the input file. The " <<
"relevant boundary condition is:\n\n" << bc << std::endl);
return bcs_tm;
}
Teuchos::RCP<NOX::Abstract::MultiVector>
NOX::Thyra::Vector::
createMultiVector(int numVecs, NOX::CopyType type) const
{
TEUCHOS_TEST_FOR_EXCEPTION(nonnull(weightVec_), std::logic_error,
"Can NOT create NOX::Thyra::MultiVector from a NOX::Thyra::Vector that contains a weighting vector! ");
// Get vector space
Teuchos::RCP<const ::Thyra::VectorSpaceBase<double> > space =
thyraVec->space();
// Create Thyra multivector
Teuchos::RCP< ::Thyra::MultiVectorBase<double> > mv =
createMembers(*space, numVecs);
// Copy vectors
if (type == NOX::DeepCopy) {
for (int i=0; i<numVecs; i++) {
Teuchos::RCP< ::Thyra::VectorBase<double> > v = mv->col(i);
::Thyra::copy(*thyraVec, v.ptr());
}
}
// Create multi-vector
Teuchos::RCP<NOX::Thyra::MultiVector> nmv =
Teuchos::rcp(new NOX::Thyra::MultiVector(mv));
return nmv;
}
bool MultiphysicsDistributor::transferExistsOnProcess(const MultiphysicsDistributor::TransferIndex index) const
{
#ifdef HAVE_PIKE_DEBUG
TEUCHOS_ASSERT( (index >= 0) && (index < transfers_.size()) );
#endif
return nonnull(transferComms_[index]);
}
bool MultiphysicsDistributor::appExistsOnProcess(const MultiphysicsDistributor::ApplicationIndex index) const
{
#ifdef HAVE_PIKE_DEBUG
TEUCHOS_ASSERT( (index >= 0) && (index < applications_.size()) );
#endif
return nonnull(applicationComms_[index]);
}
Teuchos::RCP<const Teuchos::Comm<int> > MultiphysicsDistributor::getGlobalComm() const
{
#ifdef HAVE_PIKE_DEBUG
TEUCHOS_ASSERT(nonnull(globalComm_));
#endif
return globalComm_;
}
void TpetraMultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>::initializeImpl(
const RCP<const TpetraVectorSpace<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraVectorSpace,
const RCP<const ScalarProdVectorSpaceBase<Scalar> > &domainSpace,
const RCP<TpetraMultiVector_t> &tpetraMultiVector
)
{
#ifdef THYRA_DEBUG
TEUCHOS_ASSERT(nonnull(tpetraVectorSpace));
TEUCHOS_ASSERT(nonnull(domainSpace));
TEUCHOS_ASSERT(nonnull(tpetraMultiVector));
// ToDo: Check to make sure that tpetraMultiVector is compatible with
// tpetraVectorSpace.
#endif
tpetraVectorSpace_ = tpetraVectorSpace;
domainSpace_ = domainSpace;
tpetraMultiVector_.initialize(tpetraMultiVector);
this->updateSpmdSpace();
}
/**
* \brief Create a new BasicProcess based on a guider
*
* Creating the process does not create the thread associated with this
* process. This has to be done in the derived class constructor, because
* only the derived class knows the work function that must be executed
* by the thread.
*/
BasicProcess::BasicProcess(GuiderBase *guider, TrackerPtr tracker,
persistence::Database database)
: _guider(nonnull(guider)),
_exposure(guider->exposure()), _imager(guider->imager()),
_tracker(tracker), _database(database) {
debug(LOG_DEBUG, DEBUG_LOG, 0,
"construct a guiding process: exposure %s",
_guider->exposure().toString().c_str());
}
bool MockModelEvaluator::isLocallyConverged() const
{
TEUCHOS_ASSERT(nonnull(solver_));
if (iterationTrigger_ == solver_->getNumberOfIterations() )
if (mode_ == LOCAL_FAILURE)
return false;
return true;
}
bool MockModelEvaluator::isGloballyConverged() const
{
TEUCHOS_ASSERT(nonnull(solver_));
if (iterationTrigger_ == solver_->getNumberOfIterations() )
if (mode_ == GLOBAL_CONVERGENCE)
return true;
return false;
}
NOX::Thyra::Vector::
Vector(const NOX::Thyra::Vector& source, NOX::CopyType type) :
thyraVec(source.thyraVec->clone_v())
{
if (nonnull(source.weightVec_)) {
weightVec_ = source.weightVec_;
tmpVec_ = source.tmpVec_->clone_v();
do_implicit_weighting_ = source.do_implicit_weighting_;
}
}
void MockModelEvaluator::solve()
{
TEUCHOS_ASSERT(nonnull(solver_));
if (responseFreezeIteration_ <= (solver_->getNumberOfIterations()+1) ) {
// do nothing - freeze the response
}
else
responseValues_[0][0] += 1.0;
}
std::ostream& ParameterList::print(std::ostream& os, const PrintOptions &printOptions ) const
{
const int indent = printOptions.indent();
const bool showTypes = printOptions.showTypes();
const bool showFlags = printOptions.showFlags();
const bool showDoc = printOptions.showDoc();
const std::string linePrefix(indent,' ');
RCP<FancyOStream>
out = getFancyOStream(rcp(&os,false));
OSTab tab(out,indent);
if (this->begin() == this->end()) {
*out <<"[empty list]" << std::endl;
}
else {
// Print parameters first
for (ConstIterator i = this->begin(); i != this->end(); ++i)
{
const std::string &name_i = this->name(i);
const ParameterEntry &entry_i = entry(i);
RCP<const ParameterEntryValidator>
validator = entry_i.validator();
if(entry_i.isList())
continue;
*out << name_i;
const std::string &docString = entry_i.docString();
if(showTypes)
*out << " : " << entry_i.getAny(false).typeName();
*out << " = "; entry_i.leftshift(os,showFlags); *out << std::endl;
if (showDoc) {
if (nonnull(validator)) {
validator->printDoc(docString,OSTab(os).o());
}
else if (docString.length()) {
StrUtils::printLines(OSTab(out).o(),"# ",docString);
}
}
}
// Print sublists second
for (ConstIterator i = this->begin(); i != this->end(); ++i)
{
const ParameterEntry &entry_i = entry(i);
if(!entry_i.isList())
continue;
const std::string &docString = entry_i.docString();
const std::string &name_i = this->name(i);
*out << name_i << " -> " << std::endl;
if( docString.length() && showDoc ) {
StrUtils::printLines(OSTab(out).o(),"# ",docString);
}
getValue<ParameterList>(entry_i).print(OSTab(out).o(), printOptions.copy().indent(0));
}
}
return os;
}
void MatrixFreeJacobianOperator<Scalar>::
setBaseEvaluationToRawThyra(const Teuchos::RCP<const ::Thyra::VectorBase<Scalar> >& x_base,
const Teuchos::RCP<const ::Thyra::VectorBase<Scalar> >& f_base,
const Teuchos::RCP< ::Thyra::ModelEvaluator<Scalar> > model)
{
TEUCHOS_ASSERT(setup_called_);
TEUCHOS_ASSERT(nonnull(x_base));
TEUCHOS_ASSERT(nonnull(f_base));
TEUCHOS_ASSERT(nonnull(model));
x_base_ = x_base;
f_base_ = f_base;
x_perturb_ = x_base_->space()->createMember();
f_perturb_ = f_base_->space()->createMember();
if (difference_type_ == Centered)
f2_perturb_ = f_base_->space()->createMember();
model_ = model;
base_evaluation_type_ = RawThyra;
}
Teuchos::RCP<Thyra::ProductMultiVectorBase<Scalar> >
Thyra::nonconstCastOrCreateSingleBlockProductMultiVector(
const RCP<const DefaultProductVectorSpace<Scalar> > &productSpace,
const RCP<MultiVectorBase<Scalar> > &mv
)
{
const RCP<ProductMultiVectorBase<Scalar> > pmv =
Teuchos::rcp_dynamic_cast<ProductMultiVectorBase<Scalar> >(mv);
if (nonnull(pmv))
return pmv;
return defaultProductMultiVector<Scalar>(productSpace, Teuchos::tuple(mv)());
}
void TransientStepper::registerModelEvaluator(const Teuchos::RCP<pike::BlackBoxModelEvaluator>& me)
{
TEUCHOS_ASSERT(!registrationComplete_);
TEUCHOS_ASSERT(nonnull(solver_));
solver_->registerModelEvaluator(me);
// Store off the transient model evaluators. We do suppor the
// case where there can be a mix of steady-state and transient
// model evaluators, so we only consider the transient ones for
// determinig time step and accepting a completed time step solve.
if (me->isTransient())
transientModels_.push_back(me);
}
TEUCHOS_UNIT_TEST(global_data, builder)
{
Teuchos::RCP<panzer::GlobalData> gd;
TEST_ASSERT(is_null(gd));
{
gd = panzer::createGlobalData(false);
TEST_ASSERT(nonnull(gd));
TEST_ASSERT(nonnull(gd->pl));
TEST_ASSERT(is_null(gd->os));
}
{
gd = panzer::createGlobalData(true);
TEST_ASSERT(nonnull(gd));
TEST_ASSERT(nonnull(gd->pl));
TEST_ASSERT(nonnull(gd->os));
}
}
int main(void)
{
try {
base *b = new derived();
b = 0;
//printf("%s\n", typeid(*b).name()); // g++47 and VC2010 throws if b is null.
//printf("%s\n", typeid(1 ? *b : *b).name()); // VC2010 does not throw if b is null. g++47 throws.
printf("%s\n", typeid(nonnull(*b)).name()); // VC2010 throws if b is null. g++47 seg-fault.
}
catch(const std::exception & e)
{
printf("Err: %s\n", e.what());
}
}
void print_import_result (gpgme_import_result_t r)
{
gpgme_import_status_t st;
for (st=r->imports; st; st = st->next)
{
printf (" fpr: %s err: %d (%s) status:", nonnull (st->fpr),
st->result, gpgme_strerror (st->result));
if (st->status & GPGME_IMPORT_NEW)
fputs (" new", stdout);
if (st->status & GPGME_IMPORT_UID)
fputs (" uid", stdout);
if (st->status & GPGME_IMPORT_SIG)
fputs (" sig", stdout);
if (st->status & GPGME_IMPORT_SUBKEY)
fputs (" subkey", stdout);
if (st->status & GPGME_IMPORT_SECRET)
fputs (" secret", stdout);
putchar ('\n');
}
printf ("key import summary:\n"
" considered: %d\n"
" no user id: %d\n"
" imported: %d\n"
" imported_rsa: %d\n"
" unchanged: %d\n"
" new user ids: %d\n"
" new subkeys: %d\n"
" new signatures: %d\n"
" new revocations: %d\n"
" secret read: %d\n"
" secret imported: %d\n"
" secret unchanged: %d\n"
" skipped new keys: %d\n"
" not imported: %d\n",
r->considered,
r->no_user_id,
r->imported,
r->imported_rsa,
r->unchanged,
r->new_user_ids,
r->new_sub_keys,
r->new_signatures,
r->new_revocations,
r->secret_read,
r->secret_imported,
r->secret_unchanged,
r->skipped_new_keys,
r->not_imported);
}
void
MultiphysicsDistributor::setup(const Teuchos::RCP<const Teuchos::Comm<int> >& globalComm,
bool printCommDistribution)
{
TEUCHOS_ASSERT(!setupCalled_);
TEUCHOS_ASSERT(nonnull(globalComm));
// Duplicate the global comm to get a separate context for this
// objects's communication
globalComm_ = globalComm->duplicate();
TEUCHOS_TEST_FOR_EXCEPTION((applications_.size() < 1),
std::logic_error,
"Error: No apps were registered with the distributor!");
this->buildComms();
this->buildOStreams();
//*************************************
// Print the comm details
//*************************************
if (printCommDistribution) {
for (std::size_t app = 0; app < applications_.size(); ++app) {
const std::vector<int>& appRanks = applications_[app].processes;
*pout_ << "Application Ranks(" << applications_[app].name << ") = ";
for (std::vector<int>::const_iterator r=appRanks.begin(); r != appRanks.end(); ++r) {
if (r != appRanks.begin())
*pout_ << ",";
*pout_ << *r;
}
*pout_ << std::endl;
}
for (std::size_t t = 0; t < transferRanks_.size(); ++t) {
*pout_ << "Transfer Ranks(" << transferNames_[t] << ") = ";
for (std::vector<int>::const_iterator r=transferRanks_[t].begin(); r != transferRanks_[t].end(); ++r) {
if (r != transferRanks_[t].begin())
*pout_ << ",";
*pout_ << *r;
}
*pout_ << std::endl;
}
}
setupCalled_ = true;
}
double
NOX::Thyra::Vector::
norm(const NOX::Abstract::Vector& weights) const
{
const NOX::Thyra::Vector& w =
dynamic_cast<const NOX::Thyra::Vector&>(weights);
if (nonnull(weightVec_) && do_implicit_weighting_) {
::Thyra::copy(*thyraVec, outArg(*tmpVec_));
::Thyra::ele_wise_scale(*weightVec_, outArg(*tmpVec_));
return ::Thyra::norm_2(*w.thyraVec, *tmpVec_);
}
return ::Thyra::norm_2(*w.thyraVec, *thyraVec);
}
void XMLParameterListWriter::buildInitialValidatorMap(
const ParameterList& p,
ValidatortoIDMap& validatorIDsMap) const
{
for (ParameterList::ConstIterator i=p.begin(); i!=p.end(); ++i) {
const ParameterEntry& entry = p.entry(i);
if(entry.isList()){
buildInitialValidatorMap(
getValue<ParameterList>(entry),
validatorIDsMap);
}
else if(nonnull(entry.validator())){
validatorIDsMap.insert(entry.validator());
}
}
}
double
NOX::Thyra::Vector::
innerProduct(const NOX::Abstract::Vector& y) const
{
const NOX::Thyra::Vector& yy =
dynamic_cast<const NOX::Thyra::Vector&>(y);
if (nonnull(weightVec_) && do_implicit_weighting_) {
::Thyra::copy(*thyraVec, tmpVec_.ptr());
// double the scaling one for each vector in product
::Thyra::ele_wise_scale(*weightVec_, outArg(*tmpVec_));
::Thyra::ele_wise_scale(*weightVec_, outArg(*tmpVec_));
return thyraVec->space()->scalarProd(*tmpVec_, *yy.thyraVec);
}
return thyraVec->space()->scalarProd(*thyraVec, *yy.thyraVec);
}
void MatrixFreeJacobianOperator<Scalar>::
setBaseEvaluationToNOXGroup(const Teuchos::RCP<const NOX::Abstract::Group>& base_group)
{
TEUCHOS_ASSERT(setup_called_);
TEUCHOS_ASSERT(nonnull(base_group));
base_group_ = Teuchos::rcp_dynamic_cast<const NOX::Thyra::Group>(base_group,true);
x_base_ = Teuchos::rcp_dynamic_cast<const NOX::Thyra::Vector>(base_group_->getXPtr(),true)->getThyraRCPVector();
f_base_ = Teuchos::rcp_dynamic_cast<const NOX::Thyra::Vector>(base_group_->getFPtr(),true)->getThyraRCPVector();
x_perturb_ = ::Thyra::createMember(x_base_->space());
f_perturb_ = ::Thyra::createMember(f_base_->space());
if (difference_type_ == Centered)
f2_perturb_ = ::Thyra::createMember(f_base_->space());
model_ = base_group_->getModel();
base_evaluation_type_ = NoxGroup;
}
pike::SolveStatus LocalModelFailure::checkStatus(const pike::Solver& solver, const CheckType checkType)
{
if (is_null(application_)) {
application_ = solver.getModelEvaluator(applicationName_);
TEUCHOS_ASSERT(nonnull(application_));
}
if (solver.getNumberOfIterations() == 0) {
status_ = pike::UNCHECKED;
return status_;
}
// Triggers a failure if the local model fails to converge.
isLocallyConverged_ = application_->isLocallyConverged();
status_ = isLocallyConverged_ ? pike::UNCONVERGED : pike::FAILED;
return status_;
}
void
StringValidatorDependencyXMLConverter::convertSpecialValidatorAttributes(
RCP<const ValidatorDependency> dependency,
XMLObject& xmlObj,
ValidatortoIDMap& validatorIDsMap) const
{
RCP<const StringValidatorDependency> castedDependency =
rcp_dynamic_cast<const StringValidatorDependency>(dependency, true);
XMLObject valueMapTag(getValuesAndValidatorsTag());
const StringValidatorDependency::ValueToValidatorMap valuesAndValidators =
castedDependency->getValuesAndValidators();
for(
StringValidatorDependency::ValueToValidatorMap::const_iterator it =
valuesAndValidators.begin();
it != valuesAndValidators.end();
++it)
{
XMLObject pairTag(getPairTag());
pairTag.addAttribute(getValueAttributeName(), it->first);
if(validatorIDsMap.find(it->second) == validatorIDsMap.end()){
validatorIDsMap.insert(it->second);
}
pairTag.addAttribute(getValidatorIdAttributeName(),
validatorIDsMap.find(it->second)->second);
valueMapTag.addChild(pairTag);
}
xmlObj.addChild(valueMapTag);
RCP<const ParameterEntryValidator> defaultVali =
castedDependency->getDefaultValidator();
if(nonnull(defaultVali)){
if(validatorIDsMap.find(defaultVali) == validatorIDsMap.end()){
validatorIDsMap.insert(defaultVali);
}
xmlObj.addAttribute(
getDefaultValidatorIdAttributeName(),
validatorIDsMap.find(defaultVali)->second);
}
}
double
NOX::Thyra::Vector::
norm(NOX::Abstract::Vector::NormType type) const
{
if (nonnull(weightVec_) && do_implicit_weighting_) {
::Thyra::copy(*thyraVec, outArg(*tmpVec_));
::Thyra::ele_wise_scale(*weightVec_, outArg(*tmpVec_));
if (type == NOX::Abstract::Vector::TwoNorm)
return ::Thyra::norm_2(*tmpVec_);
else if (type == NOX::Abstract::Vector::OneNorm)
return ::Thyra::norm_1(*tmpVec_);
else
return ::Thyra::norm_inf(*tmpVec_);
}
else {
if (type == NOX::Abstract::Vector::TwoNorm)
return ::Thyra::norm_2(*thyraVec);
else if (type == NOX::Abstract::Vector::OneNorm)
return ::Thyra::norm_1(*thyraVec);
else
return ::Thyra::norm_inf(*thyraVec);
}
}
static help_word_t *help_add_word(help_node_t *n, const char *text);
static void help_delete_node(help_node_t *n);
static void help_delete_word(help_word_t *w);
static int help_load_directory(help_index_t *hi,
const char *directory,
const char *relative);
static int help_load_file(help_index_t *hi,
const char *filename,
const char *relative,
time_t mtime);
static help_node_t *help_new_node(const char *filename, const char *anchor,
const char *section, const char *text,
time_t mtime, off_t offset,
size_t length)
__attribute__((nonnull(1,3,4)));
static int help_sort_by_name(help_node_t *p1, help_node_t *p2);
static int help_sort_by_score(help_node_t *p1, help_node_t *p2);
static int help_sort_words(help_word_t *w1, help_word_t *w2);
/*
* 'helpDeleteIndex()' - Delete an index, freeing all memory used.
*/
void
helpDeleteIndex(help_index_t *hi) /* I - Help index */
{
help_node_t *node; /* Current node */
"Manufacturer") #define DISPLAY_MANUFACTURER_URL_STRING ( \ "ManufacturerURL") #define DISPLAY_MODEL_DESCRIPTION_STRING ( \ "ModelDescription") #define DISPLAY_MODEL_NAME_STRING ( \ "ModelName") #define DISPLAY_SERIAL_NUMBER_STRING ( \ "SerialNumber") #define DISPLAY_PRESENTATION_URL_STRING ( \ "PresentationURL") /* INFO: */ static int DisplayPrintArgumentEntry( const char * const, const char * const, const char, const char) __attribute__((nonnull (1))); static int DisplayPrintArgumentHeader( const StructuresDynamicArgument * const, const unsigned int, const char, const char) __attribute__((nonnull (1))); static int DisplayPrintArgumentList( const StructuresDynamicArgument * const, const unsigned int, const char) __attribute__((nonnull (1))); static int DisplayPrintActionEntry(const char * const, const char * const, const char) __attribute__((nonnull (1, 2))); static int DisplayPrintActionHeader( const StructuresDynamicAction * const, const unsigned int, const char) __attribute__((nonnull (1))); static int DisplayPrintActionList(const StructuresDynamicAction * const, const unsigned int, const char) __attribute__((nonnull (1))); static int DisplayPrintAllowedValueEntry(const char * const, const char * const, const char, const char) __attribute__((nonnull (1,
