Context Class Reference

#include <context.h>

Collaboration diagram for Context:

Static Public Member Functions
static void	readPropertyFile (FileType, const MString &fileName)
static MInt	propertyLength (const MString &name, MInt solverId=m_noSolvers)
	Returns the number of elements of a property. More...
static void	assertPropertyLength (const MString &name, const MInt length, const MInt solverId=m_noSolvers)
	Assert that the length of a property matches the given length. More...
static MInt	propertySolverId (const MString &name, MInt solverId=m_noSolvers)
	Returns the number of elements of a property. More...
static MBool	propertyExists (const MString &name, MInt solver=m_noSolvers)
	This function checks if a property exists in general. More...
static MBool	solverPropertyExists (const MString &name, MInt solver)
	Checks existence of a solver property details This function returns true, if the solver property with the requested name exists for the requested solver. More...
static void	clear ()
static void	init ()
	This intializes the property Map. More...
static void	addProperty (MProperty *)
	This method adds properties. More...
static void	writeProperties (char *fileName)
static void	writePropertiesHumanReadable ()
	Write the properties into a text file. More...
static void	initializationProcessFinished ()
	Sets flag to forbide property access. More...
static void	communicateProperties ()
	Communicates properties to check if default falues match. More...
static std::list< MProperty * > *	receiveProperties (MInt rank)
	Receives a property list from another cpu. More...
static void	sendProperties (MInt rank)
	Sends the property list to another cpu. More...
static void	checkPropertyViolation (MInt partnerrank, std::list< MProperty * > *prop)
	Checks if local properties differ from received properties. More...
static MString	propertyFileName ()
	Return name of most recently read property file. More...
static MString	propertyFileText ()
	Return unprocessed content of most recently read property file. More...
static void	dump (const MString &fileName)
	Dump all properties to text file. More...
template<typename T >
static T	getBasicProperty (const MString name, const MString &nameOfCallingFunction, const T *default_value, MInt pos=0)
template<typename T >
static T	getBasicProperty (const MString name, const MString &nameOfCallingFunction, MInt pos=0)
template<typename T >
static T	getSolverProperty (const MString name, const MInt solverId, const MString &nameOfCallingFunction, const T *default_value, MInt pos=0)
template<typename T >
static T	getSolverProperty (const MString name, const MInt solverId, const MString &nameOfCallingFunction, MInt pos=0)

Static Private Member Functions
template<typename T , typename F >
static T	getBasicPropertyImplicit (const MString &nameOfCallingFunction, const MString &name, MBool has_default, const T *defaultValue, MInt position, F &&f)
	Returns the value of the requested basic level property (implicit). More...
static MInt	getBasicPropertyOverloaded (const MString &nameOfCallingFunction, const MString &name, MBool has_default, const MInt *default_value, MInt pos)
static MFloat	getBasicPropertyOverloaded (const MString &nameOfCallingFunction, const MString &name, MBool has_default, const MFloat *default_value, MInt pos)
static MString	getBasicPropertyOverloaded (const MString &nameOfCallingFunction, const MString &name, MBool has_default, const MString *default_value, MInt pos)
	Returns the value of the requested basic property. overloaded. More...
static MBool	getBasicPropertyOverloaded (const MString &nameOfCallingFunction, const MString &name, MBool has_default, const MBool *default_value, MInt pos)
template<typename T , typename F >
static T	getSolverPropertyImplicit (const MString &nameOfCallingFunction, const MString &name, const MInt solverId, MBool has_default, const T *defaultValue, MInt position, F &&f)
	Returns the value of the requested solver property (implicit). More...
static MInt	getSolverPropertyOverloaded (const MString &nameOfCallingFunction, const MString &name, const MInt solverId, MBool has_default, const MInt *default_value, MInt pos)
static MFloat	getSolverPropertyOverloaded (const MString &nameOfCallingFunction, const MString &name, const MInt solverId, MBool has_default, const MFloat *default_value, MInt pos)
static MString	getSolverPropertyOverloaded (const MString &nameOfCallingFunction, const MString &name, const MInt solverId, MBool has_default, const MString *default_value, MInt pos)
	Returns the value of the requested solver property. overloaded. More...
static MBool	getSolverPropertyOverloaded (const MString &nameOfCallingFunction, const MString &name, const MInt solverId, MBool has_default, const MBool *default_value, MInt pos)
static MBool	isSameValue (const MFloat v1, const MFloat v2)
static MBool	isSameValue (const MBool v1, const MBool v2)
static MBool	isSameValue (const MInt v1, const MInt v2)
static MBool	isSameValue (const MString v1, const MString v2)

Static Private Attributes
static IONetcdf *	m_IONetcdf
static IOToml *	m_IOToml
static MString	m_name
static MInt	m_noSolvers
static propertyMap *	m_propertyMap
static propertyMap *	m_propertyMapLowercase
static zoneMap *	m_zoneMap
static assembly *	m_assembly
static std::pair< propertyMap::iterator, propertyMap::iterator >	m_pair
static MString	m_propertyFileOutputName
static MString	m_propertyFileText
static MInt	m_fileType
static MBool	m_checkingProperties

Detailed Description

This class manages the properties that are used in the MAIA. The functions and members are statical so that you can acces the properties from every where within the program. The class only stores the pointers to the property structs, and not the structs themselves. For storing those pointers a STL multimap is used with the names of the properties as keys. The class has two template functions for a more convienient useage. To get a basic property, simply call the getBasicProperty() function, with the property name. Furthermore, you can specify a default value and a the position, in case the property is an array. To get a solver specific property, simply call the getSolverProperty() function, with the property name and the solverId. Furthermore, you can specify a default value and a the position, in case the property is an array.

Definition at line 80 of file context.h.

Member Function Documentation

addProperty()

void Context::addProperty ( MProperty *  p )

static

Definition at line 453 of file context.cpp.

                                      {
  //  TRACE();
 
  const pair<const MString, MProperty*> mp(p->name, p);
 
  // produce the lowercase variant of the name to warn if property exists with different case
  MString nameL = p->name;
  std::transform(nameL.begin(), nameL.end(), nameL.begin(), [](unsigned char c) { return std::tolower(c); });
 
  const pair<const MString, MProperty*> mpL(nameL, p);
 
  // check if the lowercase variant of this property already exists but no regular-case variant
  if(!(m_propertyMapLowercase->find(nameL) == m_propertyMapLowercase->end())
     && (m_propertyMap->find(p->name) == m_propertyMap->end())) {
    mTerm(1, AT_,
          "There are multiple occurrences of the property " + p->name
              + " with different cases. This should not happen!");
  }
  m_propertyMap->insert(mp);
  m_propertyMapLowercase->insert(mpL);
}

assertPropertyLength()

void Context::assertPropertyLength ( const MString &  name, const MInt  length, const MInt  solverId = m_noSolvers  )

static

Check the length of a given property, terminate if it does not match the given length.

Definition at line 559 of file context.cpp.

                                                                                              {
  const MInt propLength = propertyLength(name, solverId);
  if(propLength != length) {
    const MString isSolver = (solverId != m_noSolvers) ? " for solver #" + std::to_string(solverId) : "";
    TERMM(1, "Property '" + name + "'" + isSolver + " has the wrong length, it is of length "
                 + std::to_string(Context::propertyLength(name)) + " but there should be " + std::to_string(length)
                 + " values!");
  }
}

checkPropertyViolation()

void Context::checkPropertyViolation ( MInt  partnerrank, std::list< MProperty * > *  prop  )

static

Author

Andreas Lintermann

Date

9.12.2010

Parameters

[in]	the	rank the partner cpu
[in]	the	property list of the other cpu

This function checks if local properties differ from the properties received from the children and stops the program if values differ.

Definition at line 1256 of file context.cpp.

                                                                             {
  TRACE();
 
  MInt defaultInt = -1;
  MFloat defaultFloat = -1.0;
  MBool defaultBool = false;
  MString defaultString = " ";
 
  MInt rank = globalDomainId();
 
  // Set flag to indicate that property accesses should not be counted here
  m_checkingProperties = true;
 
  // Check local with other
  for(auto& it : *prop) {
    if(propertyExists(it->name)) {
      switch(it->type()) {
        case MINT: {
          for(MInt j = 0; j < it->elements; j++) {
            if(*(it->asInt(j)) != getSolverProperty<MInt>(it->name, it->solverId, AT_, &defaultInt, j)
               || it->solverId != propertySolverId(it->name, it->solverId)) {
              stringstream errorMessage;
              //        auto p = getProperty((*it)->name,(*it)->solverId, AT_, (MInt*) nullptr);
              errorMessage << "Poperty violation for '" << it->name << "' on CPUs: " << rank << "," << partnerrank;
              //                     << endl
              //                     << "received: name='" << (*it)->name << "', value='" << *((*it)->asInt(j))
              //                     << "', solverId='" << (*it)->solverId << "'" << endl
              //                     << "local: name = '" << p->name << "', value='" << *(p->asInt(j))
              //                     << "', solverId='" << p->solverId << "'";
              mTerm(1, AT_, errorMessage.str());
            }
          }
          break;
        }
        case MBOOL: {
          for(MInt j = 0; j < it->elements; j++) {
            if(*(it->asBool(j)) != getSolverProperty<MBool>(it->name, it->solverId, AT_, &defaultBool, j)
               || it->solverId != propertySolverId(it->name, it->solverId)) {
              stringstream errorMessage;
              errorMessage << "Poperty violation for '" << it->name << "' on CPUs: " << rank << "," << partnerrank;
              mTerm(1, AT_, errorMessage.str());
            }
          }
          break;
        }
        case MFLOAT: {
          for(MInt j = 0; j < it->elements; j++) {
            if(!approx(*(it->asFloat(j)), getSolverProperty<MFloat>(it->name, it->solverId, AT_, &defaultFloat, j),
                       MFloatEps)
               || it->solverId != propertySolverId(it->name, it->solverId)) {
              stringstream errorMessage;
              errorMessage << "Poperty violation for '" << it->name << "' on CPUs: " << rank << "," << partnerrank;
              mTerm(1, AT_, errorMessage.str());
            }
          }
          break;
        }
        case MSTRING: {
          for(MInt j = 0; j < it->elements; j++) {
            if(*(it->asString(j)) != getSolverProperty<MString>(it->name, it->solverId, AT_, &defaultString, j)
               || it->solverId != propertySolverId(it->name, it->solverId)) {
              stringstream errorMessage;
              errorMessage << "Poperty violation for '" << it->name << "' on CPUs: " << rank << "," << partnerrank;
              mTerm(1, AT_, errorMessage.str());
            }
          }
          break;
        }
        default: {
          mTerm(1, AT_, "Context::CheckPropertyViolation(): switch variable '(*it)->type' not matching any case");
        }
      }
    } else {
      MProperty* a;
      switch(it->type()) {
        case MINT: {
          a = new MProperty(it->elements, it->name, it->solverId, it->intField);
          break;
        }
        case MBOOL: {
          a = new MProperty(it->elements, it->name, it->solverId, it->boolField);
          break;
        }
        case MFLOAT: {
          a = new MProperty(it->elements, it->name, it->solverId, it->floatField);
          break;
        }
        case MSTRING: {
          a = new MProperty(it->elements, it->name, it->solverId, it->stringField);
          break;
        }
        default:
          a = new MProperty();
      }
      addProperty(a);
    }
  }
 
  // Reset flag after checking properties
  m_checkingProperties = false;
 
  // Clean up
  prop->clear();
}

clear()

void Context::clear ( )

static

This method deletes the property structs. It runs over all elements of the propertyMap and zoneMap and deletes the individual structs. Finally the zoneMap and propertyMap are deleted.

Definition at line 418 of file context.cpp.

                    {
  TRACE();
  for(propertyIterator i = m_propertyMap->begin(); i != m_propertyMap->end(); i++) {
    DEBUG("MProperty::clear:  name " << i->second->name, MAIA_DEBUG_IO);
    DEBUG("MProperty::clear:  solverId " << i->second->solverId, MAIA_DEBUG_IO);
    i->second->clear(); // remove the pointers of property
  }
  m_propertyMap->clear();
 
  for(propertyIterator i = m_propertyMapLowercase->begin(); i != m_propertyMapLowercase->end(); i++) {
    DEBUG("MProperty::clear:  name " << i->second->name, MAIA_DEBUG_IO);
    DEBUG("MProperty::clear:  solverId " << i->second->solverId, MAIA_DEBUG_IO);
    i->second->clear(); // remove the pointers of property
  }
  m_propertyMapLowercase->clear();
 
  for(zoneIterator i = m_zoneMap->begin(); i != m_zoneMap->end(); i++) {
    DEBUG("MProperty::clear()  name : " << i->second->name, MAIA_DEBUG_IO);
    DEBUG("MProperty::clear()  noSolvers : " << i->second->noSolvers, MAIA_DEBUG_IO);
    delete[] i->second->solvers;
  }
#ifdef MAIA_PRINT_PROPERTIES
  propsFromFile.close();
  propsDefault.close();
#endif
}

communicateProperties()

void Context::communicateProperties ( )

static

Author

Andreas Lintermann

Date

06.12.2010

This function communicates properties available in the property map in a tree-like structure and is called in environment->run().

1. A binary tree is built to accelerate communication
2. Starting at the leafs, properties are merged at father-nodes 2.1 Check if properties from leafs do not violate equality restrictions
3. Finish at root node (processor with id 0)

Definition at line 773 of file context.cpp.

                                    {
  TRACE();
 
  NEW_TIMER_GROUP_STATIC(m_timerGroupId, "Context");
  NEW_TIMER(timerpcheck, "Property Validity Check", m_timerGroupId);
  RECORD_TIMER_START(timerpcheck);
 
  m_log << "==============================================================" << endl;
  m_log << "  Checking property validity... ";
#ifdef MAIA_WRITE_ACCESS_PROPERTIES_FILE
  maia_properties << "==============================================================" << endl;
  maia_properties << "  Checking property validity... ";
#endif
 
  // TEST
  /*
  MInt rank = MPI_COMM_WORLD.Get_rank();
  if(rank==1)
    {
      MInt* b = new MInt();
      *b=1;
      MProperty* a = new MProperty(1,"AAA",1,b);
      addProperty(a);
    }
  else
    {
      MInt* b = new MInt();
      *b=2;
      MProperty* a = new MProperty(1,"AAA",1,b);
      addProperty(a);
    }
  */
 
  MInt noDomains = globalNoDomains();
  BinaryPropertyMPITree tree(noDomains);
  // if(rank==0)
  // tree.printTree();
 
  MInt comm_partner = 0;
 
  list<MProperty*>* left = nullptr;
  list<MProperty*>* right = nullptr;
 
  // We need to receive something from below
  if(tree.getMyLeftMPISender() != nullptr || tree.getMyRightMPISender() != nullptr) {
    if(tree.getMyLeftMPISender() != nullptr) {
      comm_partner = *(tree.getMyLeftMPISender()->getObject());
      left = receiveProperties(comm_partner);
      checkPropertyViolation(comm_partner, left);
    }
    if(tree.getMyRightMPISender() != nullptr) {
      comm_partner = *(tree.getMyRightMPISender()->getObject());
      right = receiveProperties(comm_partner);
      checkPropertyViolation(comm_partner, right);
    }
  }
 
  // Send if we are not the almighty father of the tree
  if(tree.getMyMPIReceiver() != nullptr) {
    comm_partner = *(tree.getMyMPIReceiver()->getObject());
    sendProperties(comm_partner);
  }
 
  m_log << " --->  EVERYTHING IS FINE!!!!" << endl;
  m_log << "==============================================================" << endl;
#ifdef MAIA_WRITE_ACCESS_PROPERTIES_FILE
  maia_properties << " --->  EVERYTHING IS FINE!!!!" << endl;
  maia_properties << "==============================================================" << endl;
#endif
  RECORD_TIMER_STOP(timerpcheck);
}

dump()

void Context::dump ( const MString &  fileName )

static

Definition at line 1362 of file context.cpp.

                                          {
  ofstream os(fileName);
  for(auto&& pm : *m_propertyMap) {
    const auto name = pm.first;
    const auto prop = pm.second;
    os << name << " (";
    switch(prop->propertyType) {
      case MINT:
        os << "MINT";
        break;
      case MFLOAT:
        os << "MFLOAT";
        break;
      case MSTRING:
        os << "MSTRING";
        break;
      case MBOOL:
        os << "MBOOL";
        break;
      default:
        TERMM(1, "Bad type");
    }
    os << "): ";
    for(MInt i = 0; i < prop->count(); i++) {
      if(i != 0) {
        os << ", ";
      }
      switch(prop->propertyType) {
        case MINT:
          os << prop->intField[i];
          break;
        case MFLOAT:
          os << prop->floatField[i];
          break;
        case MSTRING:
          os << prop->stringField[i];
          break;
        case MBOOL:
          os << prop->boolField[i];
          break;
        default:
          TERMM(1, "Bad type");
      }
    }
    os << std::endl;
  }
}

getBasicProperty() [1/2]

template<typename T >

static T Context::getBasicProperty ( const MString  name, const MString &  nameOfCallingFunction, const T *  default_value, MInt  pos = 0  )

inlinestatic

Definition at line 149 of file context.h.

                                          {
    const MBool hasDefault = (default_value != nullptr);
    return getBasicPropertyOverloaded(nameOfCallingFunction, name, hasDefault, default_value, pos);
  }

getBasicProperty() [2/2]

template<typename T >

static T Context::getBasicProperty ( const MString  name, const MString &  nameOfCallingFunction, MInt  pos = 0  )

inlinestatic

Definition at line 159 of file context.h.

                                                                                                    {
    T* defaultValue = nullptr;
    return getBasicPropertyOverloaded(nameOfCallingFunction, name, false, defaultValue, pos);
  }

getBasicPropertyImplicit()

template<typename T , typename F >

T Context::getBasicPropertyImplicit ( const MString &  nameOfCallingFunction, const MString &  name, MBool  has_default, const T *  defaultValue, MInt  position, F &&  f  )

staticprivate

This template function searchs for a certain property given as an argument (name). If the property exists, it will be returned. If the property does not exist, the default value will be returned (if one is given). If there is also no defaultValue, the code exits with an error.

Author

Moritz Waldmann

Date

12.2018

Definition at line 126 of file context.cpp.

                                                                                 {
  if(propertyExists(name)) {
    // lookup all properties with the requested key
    m_pair = m_propertyMap->equal_range(name);
    for(propertyIterator i = m_pair.first; i != m_pair.second; i++) {
      if(i->second->solverId == m_noSolvers) {
#ifdef MAIA_WRITE_ACCESS_PROPERTIES_FILE
        if(!m_checkingProperties) { // Count number of accesses (if not during property checking)
          i->second->noAccesses++;
        }
#endif
 
        const T pValue = f(i->second, position);
 
#ifdef MAIA_WRITE_ACCESS_PROPERTIES_FILE
        // Check for default property values specified in the property file
        if(has_default && !m_checkingProperties) {
          const T dValue = *defaultValue;
          const MBool isDefault = isSameValue(dValue, pValue);
          if(!isDefault) {
            // TODO labels:IO could be used to count properties with/without default values
            /* i->second->noOldAccesses++; */
          } else {
            std::cerr << "Property default value specified: " << name << " solverId=" << -1 << " pos=" << position
                      << " value=" << pValue << " default=" << *defaultValue << " " << nameOfCallingFunction
                      << std::endl;
          }
        }
#endif
 
        return pValue;
      }
    }
  }
  stringstream errormessage;
  errormessage << " The solver property '" << name << "' is  required for the simulation"
               << ", but was not set in the toml file!!!!";
 
  if(!has_default) {
    mTerm(1, nameOfCallingFunction, errormessage.str());
  } else {
    return *defaultValue;
  }
}

getBasicPropertyOverloaded() [1/4]

MBool Context::getBasicPropertyOverloaded ( const MString &  nameOfCallingFunction, const MString &  name, MBool  has_default, const MBool *  default_value, MInt  pos  )

staticprivate

Definition at line 227 of file context.cpp.

                                                                                {
  MBool propertyValue;
  if(m_fileType == TOML) {
    propertyValue = getBasicPropertyImplicit(nameOfCallingFunction, name, has_default, default_value, pos,
                                             [](MProperty* i, MInt p) { return (*(i)->asBool(p)); });
  } else {
    // handle the case that we have a netcdf property file
    MInt tmpDef = 0; // false
    if(has_default) {
      tmpDef = static_cast<MInt>(*default_value);
    }
    MInt tmp = getBasicPropertyImplicit(nameOfCallingFunction, name, has_default, &tmpDef, pos,
                                        [](MProperty* i, MInt p) { return (*(i)->asInt(p)); });
    propertyValue = (tmp == 1);
  }
#ifdef MAIA_PRINT_PROPERTIES
  if(propertyExists(name))
    propsFromFile << name << " = " << propertyValue << ", basic Property (MBool)" << endl;
  else
    propsDefault << name << " = " << propertyValue << ", basic Property (MBool)" << endl;
#endif
 
  return propertyValue;
}

getBasicPropertyOverloaded() [2/4]

MFloat Context::getBasicPropertyOverloaded ( const MString &  nameOfCallingFunction, const MString &  name, MBool  has_default, const MFloat *  default_value, MInt  pos  )

staticprivate

Definition at line 212 of file context.cpp.

                                                                                  {
  MFloat propertyValue;
  propertyValue = getBasicPropertyImplicit(nameOfCallingFunction, name, has_default, default_value, pos,
                                           [](MProperty* i, MInt p) { return (*(i)->asFloat(p)); });
#ifdef MAIA_PRINT_PROPERTIES
  if(propertyExists(name))
    propsFromFile << name << " = " << propertyValue << ", basic Property (MFloat)" << endl;
  else
    propsDefault << name << " = " << propertyValue << ", basic Property (MFloat)" << endl;
#endif
 
  return propertyValue;
}

getBasicPropertyOverloaded() [3/4]

MInt Context::getBasicPropertyOverloaded ( const MString &  nameOfCallingFunction, const MString &  name, MBool  has_default, const MInt *  default_value, MInt  pos  )

staticprivate

Definition at line 197 of file context.cpp.

                                                                              {
  MInt propertyValue;
  propertyValue = getBasicPropertyImplicit(nameOfCallingFunction, name, has_default, default_value, pos,
                                           [](MProperty* i, MInt p) { return (*(i)->asInt(p)); });
#ifdef MAIA_PRINT_PROPERTIES
  if(propertyExists(name))
    propsFromFile << name << " = " << propertyValue << ", basic Property (MInt)" << endl;
  else
    propsDefault << name << " = " << propertyValue << ", basic Property (MInt)" << endl;
#endif
 
  return propertyValue;
}

getBasicPropertyOverloaded() [4/4]

MString Context::getBasicPropertyOverloaded ( const MString &  nameOfCallingFunction, const MString &  name, MBool  has_default, const MString *  default_value, MInt  pos  )

staticprivate

The following 4 (one for MInt, MFloat, MString, MBool) functions provide a value for the template funtion getBasicProperty. They receive their value from the implicite function getBasicPropertyImplicit. For debugging 'MAIA_PRINT_PROPERTIES' can be defined in config.h. Each of the overloaded functions will than print the property name and corresponding value or default value to a file. This can extend the simulation time.

Author

Moritz Waldmann

Date

12.2018

Definition at line 183 of file context.cpp.

                                                                                                       {
  MString propertyValue;
  propertyValue = getBasicPropertyImplicit(nameOfCallingFunction, name, has_default, default_value, pos,
                                           [](MProperty* i, MInt p) { return (*(i)->asString(p)); });
#ifdef MAIA_PRINT_PROPERTIES
  if(propertyExists(name))
    propsFromFile << name << " = " << propertyValue << ", basic Property (MString)" << endl;
  else
    propsDefault << name << " = " << propertyValue << ", basic Property (MString)" << endl;
#endif
  return propertyValue;
}

getSolverProperty() [1/2]

template<typename T >

static T Context::getSolverProperty ( const MString  name, const MInt  solverId, const MString &  nameOfCallingFunction, const T *  default_value, MInt  pos = 0  )

inlinestatic

Definition at line 168 of file context.h.

                                                                   {
    return getSolverPropertyOverloaded(nameOfCallingFunction, name, solverId, true, default_value, pos);
  }

getSolverProperty() [2/2]

template<typename T >

static T Context::getSolverProperty ( const MString  name, const MInt  solverId, const MString &  nameOfCallingFunction, MInt  pos = 0  )

inlinestatic

Definition at line 178 of file context.h.

                                           {
    T* defaultValue = nullptr;
    return getSolverPropertyOverloaded(nameOfCallingFunction, name, solverId, false, defaultValue, pos);
  }

getSolverPropertyImplicit()

template<typename T , typename F >

T Context::getSolverPropertyImplicit ( const MString &  nameOfCallingFunction, const MString &  name, const MInt  solverId, MBool  has_default, const T *  defaultValue, MInt  position, F &&  f  )

staticprivate

This template function searchs for a certain property of a certain solver given as an argument (name, solverId). If the property exists, it will be returned. If the property does not exist, the basic property will be returned. If also the basic property does not exist, the default value will be returned (if one is given). If there is also no defaultValue, the code exits with an error.

Author

Moritz Waldmann

Date

12.2018

Definition at line 265 of file context.cpp.

                                                                                                     {
  if(solverPropertyExists(name, solverId)) {
    // lookup all properties with the requested key
    m_pair = m_propertyMap->equal_range(name);
    for(propertyIterator i = m_pair.first; i != m_pair.second; i++) {
      if(i->second->solverId == solverId) {
#ifdef MAIA_WRITE_ACCESS_PROPERTIES_FILE
        if(!m_checkingProperties) { // Count number of accesses (if not during property checking)
          i->second->noAccesses++;
        }
#endif
 
        const T pValue = f(i->second, position);
 
#ifdef MAIA_WRITE_ACCESS_PROPERTIES_FILE
        // Check for default property values specified in the property file
        if(has_default && !m_checkingProperties) {
          const T dValue = *defaultValue;
          const MBool isDefault = isSameValue(dValue, pValue);
          if(!isDefault) {
            // TODO labels:IO could be used to count properties with/without default values
            /* i->second->noOldAccesses++; */
          } else {
            std::cerr << "Property default value specified: " << name << " solverId=" << solverId << " pos=" << position
                      << " value=" << pValue << " default=" << *defaultValue << " " << nameOfCallingFunction
                      << std::endl;
          }
        }
#endif
 
        return pValue;
      }
    }
  } else if(propertyExists(name)) {
    return getBasicPropertyImplicit(nameOfCallingFunction, name, has_default, defaultValue, position, f);
  }
 
  stringstream errormessage;
  errormessage << " The solver property '" << name << "' is  required for the simulation"
               << ", but was not set in the toml file!!!!";
  if(!has_default) {
    mTerm(1, nameOfCallingFunction, errormessage.str());
  } else {
    return *defaultValue;
  }
}

getSolverPropertyOverloaded() [1/4]

MBool Context::getSolverPropertyOverloaded ( const MString &  nameOfCallingFunction, const MString &  name, const MInt  solverId, MBool  has_default, const MBool *  default_value, MInt  pos  )

staticprivate

Definition at line 380 of file context.cpp.

                                                     {
  MBool propertyValue;
  if(m_fileType == TOML) {
    propertyValue = getSolverPropertyImplicit(nameOfCallingFunction, name, solverId, has_default, default_value, pos,
                                              [](MProperty* i, MInt p) { return (*(i)->asBool(p)); });
  } else {
    // handle the case that we have a netcdf property file
    MInt tmpDef = 0; // false
    if(has_default) {
      tmpDef = static_cast<MInt>(*default_value);
    }
    MInt tmp = getBasicPropertyImplicit(nameOfCallingFunction, name, has_default, &tmpDef, pos,
                                        [](MProperty* i, MInt p) { return (*(i)->asInt(p)); });
    propertyValue = (tmp == 1);
  }
 
#ifdef MAIA_PRINT_PROPERTIES
  if(solverId != m_noSolvers) {
    if(propertyExists(name, solverId))
      propsFromFile << name << " = " << propertyValue << ", solver Property (solverId = " << solverId
                    << ", type = MBool)" << endl;
    else
      propsDefault << name << " = " << propertyValue << ", solver Property (solverId = " << solverId
                   << ", type = MBool)" << endl;
  }
#endif
  return propertyValue;
}

getSolverPropertyOverloaded() [2/4]

MFloat Context::getSolverPropertyOverloaded ( const MString &  nameOfCallingFunction, const MString &  name, const MInt  solverId, MBool  has_default, const MFloat *  default_value, MInt  pos  )

staticprivate

Definition at line 361 of file context.cpp.

                                                      {
  MFloat propertyValue;
  propertyValue = getSolverPropertyImplicit(nameOfCallingFunction, name, solverId, has_default, default_value, pos,
                                            [](MProperty* i, MInt p) { return (*(i)->asFloat(p)); });
#ifdef MAIA_PRINT_PROPERTIES
  if(solverId != m_noSolvers) {
    if(propertyExists(name, solverId))
      propsFromFile << name << " = " << propertyValue << ", solver Property (solverId = " << solverId
                    << ", type = MFloat)" << endl;
    else
      propsDefault << name << " = " << propertyValue << ", solver Property (solverId = " << solverId
                   << ", type = MFloat)" << endl;
  }
#endif
  return propertyValue;
}

getSolverPropertyOverloaded() [3/4]

MInt Context::getSolverPropertyOverloaded ( const MString &  nameOfCallingFunction, const MString &  name, const MInt  solverId, MBool  has_default, const MInt *  default_value, MInt  pos  )

staticprivate

Definition at line 343 of file context.cpp.

                                                                                                                       {
  MInt propertyValue;
  propertyValue = getSolverPropertyImplicit(nameOfCallingFunction, name, solverId, has_default, default_value, pos,
                                            [](MProperty* i, MInt p) { return (*(i)->asInt(p)); });
#ifdef MAIA_PRINT_PROPERTIES
  if(solverId != m_noSolvers) {
    if(propertyExists(name, solverId))
      propsFromFile << name << " = " << propertyValue << ", solver Property (solverId = " << solverId
                    << ", type = MInt)" << endl;
    else
      propsDefault << name << " = " << propertyValue << ", solver Property (solverId = " << solverId << ", type = MInt)"
                   << endl;
  }
#endif
  return propertyValue;
}

getSolverPropertyOverloaded() [4/4]

MString Context::getSolverPropertyOverloaded ( const MString &  nameOfCallingFunction, const MString &  name, const MInt  solverId, MBool  has_default, const MString *  default_value, MInt  pos  )

staticprivate

The following 4 (one for MInt, MFloat, MString, MBool) functions provide a value for the template funtion getSolverProperty. They receive their value from the implicite function getSolverPropertyImplicit

Author

Moritz Waldmann For debugging 'MAIA_PRINT_PROPERTIES' can be defined in config.h. Each of the overloaded functions will than print the property name, the solverId and the corresponding value or default value to a file. This can extend the simulation time.

Date

12.2018

Definition at line 324 of file context.cpp.

                                                       {
  MString propertyValue;
  propertyValue = getSolverPropertyImplicit(nameOfCallingFunction, name, solverId, has_default, default_value, pos,
                                            [](MProperty* i, MInt p) { return (*(i)->asString(p)); });
#ifdef MAIA_PRINT_PROPERTIES
  if(solverId != m_noSolvers) {
    if(propertyExists(name, solverId))
      propsFromFile << name << " = " << propertyValue << ", solver Property (solverId = " << solverId
                    << ", type = MString)" << endl;
    else
      propsDefault << name << " = " << propertyValue << ", solver Property (solverId = " << solverId
                   << ", type = MString)" << endl;
  }
#endif
  return propertyValue;
}

init()

void Context::init ( )

static

Use ts function if you want to create a new property list. If you want to load properties from file use the function readPropertyFile.

Definition at line 482 of file context.cpp.

                   {
  //  TRACE();
 
  m_propertyMap = new propertyMap;
  m_propertyMapLowercase = new propertyMap;
}

initializationProcessFinished()

void Context::initializationProcessFinished ( )

static

not yet activate, remove the comment

Author

Christoph Siewert

Date

10.2010

Definition at line 745 of file context.cpp.

                                            {
  //  TRACE();
 
#ifdef MAIA_WRITE_ACCESS_PROPERTIES_FILE
  maia_properties << endl << "--------------------------initialization process finshed--------------------------";
  maia_properties << endl
                  << "--------------------------property access not allowed anymore--------------------------" << endl
                  << endl;
#endif
  // chrs should be commented in, if properties regrouping is finished
  // writePropertiesHumanReadable();
}

isSameValue() [1/4]

static MBool Context::isSameValue ( const MBool  v1, const MBool  v2  )

inlinestaticprivate

Definition at line 222 of file context.h.

{ return (v1 == v2); }

isSameValue() [2/4]

static MBool Context::isSameValue ( const MFloat  v1, const MFloat  v2  )

inlinestaticprivate

Definition at line 221 of file context.h.

{ return approx(v1, v2, MFloatEps); }

isSameValue() [3/4]

static MBool Context::isSameValue ( const MInt  v1, const MInt  v2  )

inlinestaticprivate

Definition at line 223 of file context.h.

{ return (v1 == v2); }

isSameValue() [4/4]

static MBool Context::isSameValue ( const MString  v1, const MString  v2  )

inlinestaticprivate

Definition at line 224 of file context.h.

{ return (v1 == v2); }

propertyExists()

MBool Context::propertyExists ( const MString &  name, MInt  solver = m_noSolvers  )

static

Definition at line 494 of file context.cpp.

                                                                         {
  const MBool exists = !(m_propertyMap->find(name) == m_propertyMap->end());
  if(!exists) {
    // produce lowercase name to check for case-insensitive matches
    MString nameL = name;
    std::transform(nameL.begin(), nameL.end(), nameL.begin(), [](unsigned char c) { return std::tolower(c); });
    if(nameL == "postprocessing") { // delete this, when the two different spellings of postprocessing are delted!
      return exists;
    }
    const MBool existsCaseInsensitive = !(m_propertyMapLowercase->find(nameL) == m_propertyMapLowercase->end());
    if(existsCaseInsensitive) {
      mTerm(1, AT_,
            "Property " + name
                + " not found, but there was a case-insensitive match. Are you sure you spelled it correctly?");
    }
  }
  return exists;
}

propertyFileName()

static MString Context::propertyFileName ( )

inlinestatic

Definition at line 122 of file context.h.

{ return m_name; }

propertyFileText()

static MString Context::propertyFileText ( )

inlinestatic

Definition at line 125 of file context.h.

{ return m_propertyFileText; }

propertyLength()

MInt Context::propertyLength ( const MString &  name, MInt  solverId = m_noSolvers  )

static

This function returns the number of elements of a property. If the property exists, it returns the value given by the function count(), which is implemented in property.cpp

Author

Moritz Waldmann

Date

12.2018

Definition at line 538 of file context.cpp.

                                                               {
  if(solverPropertyExists(name, solverId)) {
    m_pair = m_propertyMap->equal_range(name);                        // lookup all properties with the requested key
    for(propertyIterator i = m_pair.first; i != m_pair.second; i++) { // search for the solverId
      if(i->second->solverId == solverId) {                           // look for the requested solverId
        return i->second->count();
      }
    }
  } else if(propertyExists(name)) {
    m_pair = m_propertyMap->equal_range(name);                        // lookup all properties with the requested key
    for(propertyIterator i = m_pair.first; i != m_pair.second; i++) { // search for the solverId
      if(i->second->solverId == m_noSolvers) {                        // look for the requested solverId
        return i->second->count();
      }
    }
  }
  return 0;
}

propertySolverId()

MInt Context::propertySolverId ( const MString &  name, MInt  solverId = m_noSolvers  )

static

This function returns the number of elements of a property. If the property exists, it returns its solverId

Author

Moritz Waldmann

Date

12.2018

Definition at line 576 of file context.cpp.

                                                                 {
  if(solverPropertyExists(name, solverId)) {
    m_pair = m_propertyMap->equal_range(name);                        // lookup all properties with the requested key
    for(propertyIterator i = m_pair.first; i != m_pair.second; i++) { // search for the solverId
      if(i->second->solverId == solverId) {                           // look for the requested solverId
        return i->second->solverId;
      }
    }
  } else if(propertyExists(name)) {
    m_pair = m_propertyMap->equal_range(name);                        // lookup all properties with the requested key
    for(propertyIterator i = m_pair.first; i != m_pair.second; i++) { // search for the solverId
      if(i->second->solverId == m_noSolvers) {                        // look for the requested solverId
        return i->second->solverId;
      }
    }
  }
  return 0;
}

readPropertyFile()

static void Context::readPropertyFile ( FileType  , const MString &  fileName  )

static

receiveProperties()

list< MProperty * > * Context::receiveProperties ( MInt  rank )

static

Author

Andreas Lintermann

Date

9.12.2010

Parameters

[in]

the

rank of the processor to commuicate with

Returns

returning a list containing all properties from the sending cpu

This function receives the properties from a given cpu in the following order

1. the sizes of all arrays
2. all integer values of the properties
3. all float (double) values of the properties
4. all string values of the properties
5. all names of the properties
6. all solverIds of the properties
7. all offsets of the properties, required to find the right values for the associated property

At the end a list of of received properties is built and returned for further investigations.

Definition at line 866 of file context.cpp.

                                                      {
  TRACE();
  // cerr << "Processor " <<  MPI_COMM_WORLD.Get_rank() << " is receiving from: " << rank << endl;
 
  MInt tag = 0;
  MPI_Status status;
 
  MInt listSizes[10];
 
  // Receive list sizes
  MPI_Recv(listSizes, 10, MPI_INT, rank, tag, MPI_COMM_WORLD, &status, AT_, "listSizes");
 
  // Receive integer array
  auto* int_ar = new MInt[listSizes[0]];
  MPI_Recv(int_ar, listSizes[0], MPI_INT, rank, tag, MPI_COMM_WORLD, &status, AT_, "int_ar");
 
  // Receive MBool array
  auto* bool_ar = new MBool[listSizes[1]];
  MPI_Recv(bool_ar, listSizes[1], MPI_C_BOOL, rank, tag, MPI_COMM_WORLD, &status, AT_, "bool_ar");
 
  // Receive float array
  auto* float_ar = new MFloat[listSizes[2]];
  MPI_Recv(float_ar, listSizes[2], MPI_DOUBLE, rank, tag, MPI_COMM_WORLD, &status, AT_, "float_ar");
 
  // Receive string array
  MChar* char_ar = new MChar[listSizes[3]];
  MPI_Recv(char_ar, listSizes[3], MPI_CHAR, rank, tag, MPI_COMM_WORLD, &status, AT_, "char_ar");
 
  // Receive name array
  MChar* char_ar2 = new MChar[listSizes[4]];
  MPI_Recv(char_ar2, listSizes[4], MPI_CHAR, rank, tag, MPI_COMM_WORLD, &status, AT_, "char_ar2");
 
  // Receive offset array
  MInt offset_sizes = listSizes[5] + listSizes[6] + listSizes[7] + listSizes[8] + listSizes[9];
  auto* offset = new MInt[offset_sizes];
  MPI_Recv(offset, offset_sizes, MPI_INT, rank, tag, MPI_COMM_WORLD, &status, AT_, "offset");
 
  // Receive offset array
  auto* solverIds = new MInt[listSizes[9]];
  MPI_Recv(solverIds, listSizes[9], MPI_INT, rank, tag, MPI_COMM_WORLD, &status, AT_, "solverIds");
 
  // Build something we can give back and handle in the comparison
  auto* proplist = new list<MProperty*>();
 
  MInt boolOffset = listSizes[5];
  MInt floatOffset = listSizes[5] + listSizes[6];
  MInt stringOffset = listSizes[5] + listSizes[6] + listSizes[7];
  MInt nameOffset = listSizes[5] + listSizes[6] + listSizes[7] + listSizes[8];
 
  // Run over all elements
  MInt i = 0;
  for(; i < boolOffset; i++) {
    MInt low_off = 0;
    MInt low_off_name = 0;
    if(i > 0) {
      low_off = offset[i - 1];
      low_off_name = offset[nameOffset + i - 1];
    }
 
    auto* a = new MInt[offset[i] - low_off];
    for(MInt j = low_off, l = 0; j < offset[i]; j++, l++) {
      a[l] = int_ar[j];
    }
 
    MString name;
    for(MInt j = low_off_name; j < offset[nameOffset + i]; j++) {
      name += char_ar2[j];
    }
 
    MProperty* prop = new MProperty(offset[i] - low_off, name, solverIds[i], a);
    proplist->push_back(prop);
 
    delete[] a;
  }
 
  for(; i < floatOffset; i++) {
    MInt low_off = 0;
    MInt low_off_name = offset[nameOffset + i - 1];
    if(i > boolOffset) {
      low_off = offset[i - 1];
    }
 
    // cerr << offset[i]<< " " << low_off << endl;
    auto* a = new MBool[offset[i] - low_off];
    for(MInt j = low_off, l = 0; j < offset[i]; j++, l++) {
      a[l] = bool_ar[j];
    }
 
    MString name;
    for(MInt j = low_off_name; j < offset[nameOffset + i]; j++) {
      name += char_ar2[j];
    }
 
    MProperty* prop = new MProperty(offset[i] - low_off, name, solverIds[i], a);
    proplist->push_back(prop);
 
    delete[] a;
  }
 
  for(; i < stringOffset; i++) {
    MInt low_off = 0;
    MInt low_off_name = offset[nameOffset + i - 1];
    if(i > floatOffset) low_off = offset[i - 1];
 
    // cerr << offset[i]<< " " << low_off << endl;
    auto* a = new MFloat[offset[i] - low_off];
    for(MInt j = low_off, l = 0; j < offset[i]; j++, l++) {
      a[l] = float_ar[j];
    }
 
    MString name;
    for(MInt j = low_off_name; j < offset[nameOffset + i]; j++)
      name += char_ar2[j];
 
    MProperty* prop = new MProperty(offset[i] - low_off, name, solverIds[i], a);
    proplist->push_back(prop);
 
    delete[] a;
  }
 
  for(; i < nameOffset; i++) {
    MInt low_off = 0;
    MInt low_off_name = offset[nameOffset + i - 1];
    if(i > stringOffset) low_off = offset[i - 1];
 
    MString a;
    for(MInt j = low_off, l = 0; j < offset[i]; j++, l++)
      a += char_ar[j];
 
    MString name;
    for(MInt j = low_off_name; j < offset[nameOffset + i]; j++)
      name += char_ar2[j];
 
    MProperty* prop = new MProperty(1, name, solverIds[i], &a);
    proplist->push_back(prop);
  }
 
  // Check all properties
  // FOR DEBUG
  /*
  MInt l=0;
  for (list<MProperty*>::iterator it = proplist->begin(); it!=proplist->end();it++,l++)
    {
      cerr << (*it)->name << " " << (*it)->solverId << ": " ;
      for (MInt j=0; j<(*it)->elements;j++)
  {
    if(l<floatOffset)
      cerr << *((*it)->asInt(j)) << " ";
    else if(l<stringOffset)
      cerr << *((*it)->asFloat(j)) << " ";
    else if(l<nameOffset)
      cerr << *((*it)->asString(j)) << " ";
  }
      cerr << endl;
    }
  */
  delete[] offset;
  delete[] solverIds;
  delete[] int_ar;
  delete[] float_ar;
  delete[] bool_ar;
  delete[] char_ar;
  delete[] char_ar2;
 
 
  return proplist;
}

sendProperties()

void Context::sendProperties ( MInt  rank )

static

Author

Andreas Lintermann

Date

9.12.2010

Parameters

[in]

the

rank of the processor to commuicate with

This function sends the own properties to a cpu given by rank. The properties are sent in the following order

1. the sizes of all arrays
2. all integer values of the properties
3. all float (double) values of the properties
4. all string values of the properties
5. all names of the properties
6. all solverIds of the properties
7. all offsets of the properties, required to find the right values for the associated property

Definition at line 1052 of file context.cpp.

                                      {
  TRACE();
 
  MInt tag = 0;
 
  // cerr << "Processor " <<  MPI_COMM_WORLD.Get_rank() << " is sending to: " << rank << endl;
  MInt listSizes[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 
  list<MProperty*> intProperties;
  list<MProperty*> floatProperties;
  list<MProperty*> stringProperties;
  list<MProperty*> boolProperties;
 
  for(auto& i : *m_propertyMap) {
    switch(i.second->type()) {
      case MINT: {
        intProperties.push_back(i.second);
        listSizes[0] += (i.second->elements);
        listSizes[5]++;
        break;
      }
      case MBOOL: {
        boolProperties.push_back(i.second);
        listSizes[1] += (i.second->elements);
        listSizes[6]++;
        break;
      }
      case MFLOAT: {
        floatProperties.push_back(i.second);
        listSizes[2] += (i.second->elements);
        listSizes[7]++;
        break;
      }
      case MSTRING: {
        stringProperties.push_back(i.second);
        listSizes[3] += (i.second->stringField->size());
        listSizes[8]++;
        break;
      }
      default: {
        mTerm(1, AT_, "Context::sendProperties(): switch variable 'i->second->type' not matching any case");
      }
    }
    listSizes[4] += (i.second->name.size());
    listSizes[9]++;
  }
 
  MInt offset_sizes = listSizes[5] + listSizes[6] + listSizes[7] + listSizes[8] + listSizes[9];
  // cerr << offset_sizes << endl;
  auto* offset = new MInt[offset_sizes];
  auto* solverIds = new MInt[listSizes[9]];
  /*
  cerr << "Number of INT properties: " << intProperties.size() << ", size = " << listSizes[0] <<  endl;
  cerr << "Number of FLOAT properties: " << floatProperties.size() << ", size = " << listSizes[1] << endl;
  cerr << "Number of STRING properties: " << stringProperties.size() << ", size = " << listSizes[2] << endl;
  cerr << "Number of NAMES: " << listSizes[7] << ", size = " << listSizes[3] << endl;
  */
 
  // Build integer array and fill sizes for offsets
  auto* int_ar = new MInt[listSizes[0]];
  MInt k = 0, m = 0, n = 0;
  for(auto& intPropertie : intProperties) {
    for(MInt j = 0; j < intPropertie->elements; j++) {
      int_ar[k] = intPropertie->intField[j];
      k++;
    }
    offset[m] = k;
    solverIds[m] = intPropertie->solverId;
    m++;
  }
 
  // Build float array
  auto* bool_ar = new MBool[listSizes[1]];
  k = 0;
  for(auto& boolPropertie : boolProperties) {
    for(MInt j = 0; j < boolPropertie->elements; j++) {
      bool_ar[k] = boolPropertie->boolField[j];
      k++;
    }
 
 
    offset[m] = k;
    solverIds[m] = boolPropertie->solverId;
    m++;
  }
 
  // Build MBool array and fill sizes for offsets
  auto* float_ar = new MFloat[listSizes[2]];
  k = 0;
  for(auto& floatPropertie : floatProperties) {
    for(MInt j = 0; j < floatPropertie->elements; j++) {
      float_ar[k] = floatPropertie->floatField[j];
      k++;
    }
 
    offset[m] = k;
    solverIds[m] = floatPropertie->solverId;
    m++;
  }
 
  // Build string array
  MChar* char_ar = new MChar[listSizes[3]];
  k = 0;
  for(auto& stringPropertie : stringProperties) {
    MString a = *(stringPropertie->asString());
    for(MInt j = 0; j < (MInt)a.size(); j++) {
      char_ar[k] = a[j];
      k++;
    }
    offset[m] = k;
    solverIds[m] = stringPropertie->solverId;
    m++;
  }
 
  // Build name array
  MChar* char_ar2 = new MChar[listSizes[4]];
  k = 0;
  for(auto& intPropertie : intProperties) {
    MString a = intPropertie->name;
    for(MChar j : a) {
      char_ar2[k] = j;
      k++;
    }
    offset[m] = k;
    m++;
  }
  for(auto& boolPropertie : boolProperties) {
    MString a = boolPropertie->name;
    for(MChar j : a) {
      char_ar2[k] = j;
      k++;
    }
    offset[m] = k;
    m++;
  }
  for(auto& floatPropertie : floatProperties) {
    MString a = floatPropertie->name;
    for(MChar j : a) {
      char_ar2[k] = j;
      k++;
    }
    offset[m] = k;
    m++;
  }
  for(auto& stringPropertie : stringProperties) {
    MString a = stringPropertie->name;
    for(MChar j : a) {
      char_ar2[k] = j;
      k++;
    }
    offset[m] = k;
    m++;
    n++;
  }
 
  // Send information about arrays
  MPI_Send(listSizes, 10, MPI_INT, rank, tag, MPI_COMM_WORLD, AT_, "listSizes");
 
  // Send integer array
  MPI_Send(int_ar, listSizes[0], MPI_INT, rank, tag, MPI_COMM_WORLD, AT_, "int_ar");
 
  // Send float array
  MPI_Send(bool_ar, listSizes[1], MPI_C_BOOL, rank, tag, MPI_COMM_WORLD, AT_, "bool_ar");
 
  // Send MBool array
  MPI_Send(float_ar, listSizes[2], MPI_DOUBLE, rank, tag, MPI_COMM_WORLD, AT_, "float_ar");
 
  // Send string array
  MPI_Send(char_ar, listSizes[3], MPI_CHAR, rank, tag, MPI_COMM_WORLD, AT_, "char_ar");
 
  // Send name array
  MPI_Send(char_ar2, listSizes[4], MPI_CHAR, rank, tag, MPI_COMM_WORLD, AT_, "char_ar2");
 
  // Send offset information
  MPI_Send(offset, offset_sizes, MPI_INT, rank, tag, MPI_COMM_WORLD, AT_, "offset");
 
  // Send solverIds
  MPI_Send(solverIds, listSizes[9], MPI_INT, rank, tag, MPI_COMM_WORLD, AT_, "solverIds");
 
  // Clean up
  delete[] offset;
  delete[] solverIds;
  delete[] int_ar;
  delete[] float_ar;
  delete[] bool_ar;
  delete[] char_ar;
  delete[] char_ar2;
  intProperties.clear();
  floatProperties.clear();
  stringProperties.clear();
  boolProperties.clear();
}

solverPropertyExists()

MBool Context::solverPropertyExists ( const MString &  name, MInt  solverId  )

static

Author

Moritz Waldmann

Date

12.2018

Definition at line 519 of file context.cpp.

                                                                      {
  if(propertyExists(name)) {
    m_pair = m_propertyMap->equal_range(name);                        // lookup all properties with the requested key
    for(propertyIterator i = m_pair.first; i != m_pair.second; i++) { // search for the solverId
      if(i->second->solverId == solverId) {                           // look for the requested solverId
        return true;
      }
    }
  }
  return false;
}

writeProperties()

static void Context::writeProperties ( char *  fileName )

static

writePropertiesHumanReadable()

void Context::writePropertiesHumanReadable ( )

static

This function closes the properties stream and writes all properties in the propertyMap to the same file including extra information like the number of accesses

Author

Christoph Siewert

Date

10.2010

Definition at line 600 of file context.cpp.

                                           {
  TRACE();
 
  // All domains write their own property access file
  {
    std::cerr << "rank " << globalDomainId() << " writing property access file. " << m_propertyFileOutputName
              << std::endl;
#ifdef MAIA_WRITE_ACCESS_PROPERTIES_FILE
    maia_properties.close();
#endif
    FILE* datei;
    datei = fopen(m_propertyFileOutputName.c_str(), "a+");
    MString tester;
    MChar buffer[100];
    MInt maxNameLength, maxElementLength;
    maxNameLength = maxElementLength = 0;
    fprintf(datei, "\n\n--------------------------property table--------------------------\n");
    for(auto& i : *m_propertyMap) {
      if(maxNameLength < ((MInt)i.first.length())) {
        maxNameLength = i.first.length();
      }
      for(MInt j = 0; j < i.second->count(); j++) {
        switch(i.second->type()) {
          case MBOOL: {
            sprintf(buffer, "%i", *i.second->asBool(j));
            tester.append(buffer);
            break;
          }
          case MINT: {
            sprintf(buffer, "%i", *i.second->asInt(j));
            tester.append(buffer);
            break;
          }
          case MFLOAT: {
            sprintf(buffer, "%G", *i.second->asFloat(j));
            tester.append(buffer);
            break;
          }
          case MSTRING: {
            tester.append(*i.second->asString(j));
            tester.append("  ");
            break;
          }
          default: {
            mTerm(1, AT_, "writePropertiesHumanReadable(): switch variable 'i->second->type' not matching any case");
          }
        }
        tester.append("; ");
      }
      if(maxElementLength < ((MInt)tester.length())) {
        maxElementLength = tester.length();
      }
      tester.clear();
    }
    maxNameLength = maxNameLength + 1;
 
    for(auto& i : *m_propertyMap) {
      switch(i.second->type()) {
        case MBOOL: {
          fprintf(datei, "%s   ", "bool");
          fprintf(datei, "%s", i.first.c_str());
          for(MInt j = 0; j < ((MInt)(maxNameLength - i.first.length())); j++)
            fprintf(datei, " ");
          fprintf(datei, "= ");
          for(MInt j = 0; j < i.second->count(); j++) {
            sprintf(buffer, "%i; ", *i.second->asBool(j));
            tester.append(buffer);
            fprintf(datei, "%i; ", i.second->boolField[j]);
          }
          for(MInt k = 0; k < ((MInt)(maxElementLength - tester.length())); k++)
            fprintf(datei, " ");
          break;
        }
        case MINT: {
          fprintf(datei, "%s    ", "int");
          fprintf(datei, "%s", i.first.c_str());
          for(MInt j = 0; j < ((MInt)(maxNameLength - i.first.length())); j++)
            fprintf(datei, " ");
          fprintf(datei, "= ");
          for(MInt j = 0; j < i.second->count(); j++) {
            sprintf(buffer, "%i; ", *i.second->asInt(j));
            tester.append(buffer);
            fprintf(datei, "%i; ", i.second->intField[j]);
          }
          for(MInt k = 0; k < ((MInt)(maxElementLength - tester.length())); k++)
            fprintf(datei, " ");
          break;
        }
        case MFLOAT: {
          fprintf(datei, "%s ", "double");
          fprintf(datei, "%s", i.first.c_str());
          for(MInt j = 0; j < ((MInt)(maxNameLength - i.first.length())); j++)
            fprintf(datei, " ");
          fprintf(datei, "= ");
          for(MInt j = 0; j < i.second->count(); j++) {
            sprintf(buffer, "%G; ", *i.second->asFloat(j));
            tester.append(buffer);
            fprintf(datei, "%G; ", i.second->floatField[j]);
          }
          for(MInt k = 0; k < ((MInt)(maxElementLength - tester.length())); k++)
            fprintf(datei, " ");
          break;
        }
        case MSTRING: {
          fprintf(datei, "%s   ", "char");
          fprintf(datei, "%s", i.first.c_str());
          for(MInt j = 0; j < ((MInt)(maxNameLength - i.first.length())); j++)
            fprintf(datei, " ");
          fprintf(datei, "= ");
          for(MInt j = 0; j < i.second->count(); j++) {
            tester.append(*i.second->asString(j));
            fprintf(datei, "\"%s\"; ", i.second->asString(j)->c_str());
          }
          for(MInt k = 0; k < ((MInt)(maxElementLength - tester.length() - 4)); k++)
            fprintf(datei, " ");
          break;
        }
 
        default: {
          fprintf(datei, "--------------ERROR--------------");
          fprintf(datei, "\n");
          fprintf(datei, "Undefined type of Property: ");
          fprintf(datei, "%s =", i.first.c_str());
          fprintf(datei, "\n");
          break;
        }
      }
      const MInt solverId = (i.second->solverId < m_noSolvers) ? i.second->solverId : -1;
      fprintf(datei, "SolverId %2i", solverId);
      fprintf(datei, " Accesses %i", i.second->noAccesses);
      fprintf(datei, " OldAccesses %i",
              i.second->noOldAccesses); // TODO labels:IO,totest,toremove not useful (anymore)?
      fprintf(datei, "\n");
      tester.clear();
    }
    fclose(datei);
  }
}

Member Data Documentation

m_assembly

assembly * Context::m_assembly

staticprivate

Definition at line 137 of file context.h.

m_checkingProperties

MBool Context::m_checkingProperties

staticprivate

Definition at line 142 of file context.h.

m_fileType

MInt Context::m_fileType

staticprivate

Definition at line 141 of file context.h.

m_IONetcdf

IONetcdf * Context::m_IONetcdf

staticprivate

Definition at line 130 of file context.h.

m_IOToml

IOToml * Context::m_IOToml

staticprivate

Definition at line 131 of file context.h.

m_name

MString Context::m_name

staticprivate

Definition at line 132 of file context.h.

m_noSolvers

MInt Context::m_noSolvers

staticprivate

Definition at line 133 of file context.h.

m_pair

pair< propertyMap::iterator, propertyMap::iterator > Context::m_pair

staticprivate

Definition at line 138 of file context.h.

m_propertyFileOutputName

MString Context::m_propertyFileOutputName

staticprivate

Definition at line 139 of file context.h.

m_propertyFileText

MString Context::m_propertyFileText

staticprivate

Definition at line 140 of file context.h.

m_propertyMap

propertyMap * Context::m_propertyMap

staticprivate

Definition at line 134 of file context.h.

m_propertyMapLowercase

propertyMap * Context::m_propertyMapLowercase

staticprivate

Definition at line 135 of file context.h.

m_zoneMap

zoneMap * Context::m_zoneMap

staticprivate

Definition at line 136 of file context.h.

---

The documentation for this class was generated from the following files:

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/IO/context.h
• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/IO/context.cpp