inp::BCBaseDeck Struct Reference

User-input data for particle neighbor search. More...

#include <bcBaseDeck.h>

Collaboration diagram for inp::BCBaseDeck:

Public Member Functions
	BCBaseDeck (const json &j=json({}), std::string type="Force_BC")
	Constructor.
	BCBaseDeck (bool isRegionActive, geom::GeomData regionGeomData=geom::GeomData(), std::vector< size_t > pList=std::vector< size_t >(), std::vector< size_t > pNotList=std::vector< size_t >(), std::string timeFnType="", std::vector< double > timeFnParams=std::vector< double >(), std::string spatialFnType="", std::vector< double > spatialFnParams=std::vector< double >(), std::vector< size_t > direction=std::vector< size_t >(), bool isDisplacementZero=false)
	Constructor.
void	readFromJson (const json &j, std::string type)
	Reads from json object.
std::string	printStr (int nt=0, int lvl=0) const
	Returns the string containing printable information about the object.
void	print (int nt=0, int lvl=0) const
	Prints the information about the object.

Static Public Member Functions
static const std::vector< Field< BCBaseDeck > > &	fields ()
	The fields of the block itself.
static const std::vector< Field< BCBaseDeck > > &	timeFunctionFields ()
	The fields of the Time_Function sub-block.
static const std::vector< Field< BCBaseDeck > > &	spatialFunctionFields ()
	The fields of the Spatial_Function sub-block.
static json	getExampleJson (const json &given=json::object(), const geom::GeomData *region=nullptr)
	Returns example JSON object for ModelDeck configuration.
static json	getExampleJson (const std::string &)=delete
	Rejects a value given where a set of named values is expected.
static json	getExampleJson (const char *)=delete
	Rejects a value given where a set of named values is expected.

Data Fields
std::string	d_type
	Method for applying force. E.g., Force_BC, Displacement_BC, IC.
std::string	d_selectionType
	Method for applying force e.g.
bool	d_isRegionActive
	Flag that indicates if region-based application of boundary condition is active. So cases of 'region', 'region_with_include_list', 'region_with_exclude_list', and 'region_with_include_list_with_exclude_list' will have region-based application of boundary condition.
geom::GeomData	d_regionGeomData
	Region geometry (if any)
std::vector< size_t >	d_pList
	List of particles (if any)
std::vector< size_t >	d_pNotList
	List of particles to not include (if any)
std::string	d_timeFnType
	Name of the formula with respect to time.
std::string	d_spatialFnType
	Name of the formula of with respect to spatial coordinate.
std::vector< size_t >	d_direction
	List of dofs on which this bc will be applied.
std::vector< double >	d_timeFnParams
	List of parameters for function wrt time.
std::vector< double >	d_spatialFnParams
	List of parameters for function wrt spatial coordinate.
bool	d_isDisplacementZero
	Specify if this bc corresponds to zero displacement condition.
std::string	d_icType
	Type.
util::Point	d_icVec
	Initial velocity vector.

Detailed Description

User-input data for particle neighbor search.

Definition at line 26 of file bcBaseDeck.h.

Constructor & Destructor Documentation

BCBaseDeck() [1/2]

inp::BCBaseDeck::BCBaseDeck ( const json &  j = json({}), std::string  type = "Force_BC"  )

inline

Constructor.

Definition at line 110 of file bcBaseDeck.h.

                                    {}), std::string type = "Force_BC") :
        d_type(type), d_isRegionActive(false), d_isDisplacementZero(false) {
      readFromJson(j, type);
    };

BCBaseDeck() [2/2]

inp::BCBaseDeck::BCBaseDeck ( bool  isRegionActive, geom::GeomData  regionGeomData = geom::GeomData(), std::vector< size_t >  pList = std::vector<size_t>(), std::vector< size_t >  pNotList = std::vector<size_t>(), std::string  timeFnType = "", std::vector< double >  timeFnParams = std::vector<double>(), std::string  spatialFnType = "", std::vector< double >  spatialFnParams = std::vector<double>(), std::vector< size_t >  direction = std::vector<size_t>(), bool  isDisplacementZero = false  )

inline

Constructor.

Definition at line 118 of file bcBaseDeck.h.

        : d_isRegionActive(isRegionActive), d_regionGeomData(regionGeomData),
          d_pList(pList), d_pNotList(pNotList), d_timeFnType(timeFnType), d_timeFnParams(timeFnParams),
          d_spatialFnType(spatialFnType), d_spatialFnParams(spatialFnParams),
          d_direction(direction), d_isDisplacementZero(isDisplacementZero) {
 
      // fix selection type
      if (d_isRegionActive) {
        d_selectionType = "region";
        d_isRegionActive = true;
        if (d_pList.size() > 0)
          d_selectionType += "_with_include_list";
 
        if (d_pNotList.size() > 0)
          d_selectionType += "_with_exclude_list";
      } else {
        if (d_pList.size() > 0)
          d_selectionType = "particle";
      }
 
      if (d_isRegionActive) {
        // create a geometry object based on the data
        geom::createGeomObject(d_regionGeomData);
      }
    };

References geom::createGeomObject(), d_isRegionActive, d_pList, d_pNotList, d_regionGeomData, and d_selectionType.

Here is the call graph for this function:

Member Function Documentation

fields()

static const std::vector< Field< BCBaseDeck > > & inp::BCBaseDeck::fields ( )

inlinestatic

The fields of the block itself.

A list that is empty and a displacement that is not held are left out of the block, which is how the decks in the repository are written.

Returns

fields The field table

Definition at line 162 of file bcBaseDeck.h.

                                                        {
      static const std::vector<Field<BCBaseDeck>> f = {
          field<BCBaseDeck, std::vector<size_t>>(
              &BCBaseDeck::d_pList, "Particle_List", {},
              "Particles the condition applies to", {},
              [](const std::vector<size_t> &v) { return !v.empty(); }),
          field<BCBaseDeck, std::vector<size_t>>(
              &BCBaseDeck::d_pNotList, "Particle_Exclude_List", {},
              "Particles the condition does not apply to", {},
              [](const std::vector<size_t> &v) { return !v.empty(); }),
          field<BCBaseDeck, std::vector<size_t>>(
              &BCBaseDeck::d_direction, "Direction", {},
              "Components the condition acts on, counted from one", {},
              [](const std::vector<size_t> &v) { return !v.empty(); }),
          field<BCBaseDeck, bool>(
              &BCBaseDeck::d_isDisplacementZero, "Zero_Displacement", false,
              "Hold the displacement at zero", {},
              [](const bool &v) { return v; }),
      };
      return f;
    }

References d_direction, d_isDisplacementZero, d_pList, d_pNotList, and inp::field().

Referenced by getExampleJson(), and readFromJson().

Here is the call graph for this function:

Here is the caller graph for this function:

getExampleJson() [1/3]

static json inp::BCBaseDeck::getExampleJson ( const char *  )

staticdelete

Rejects a value given where a set of named values is expected.

A type passed on its own would convert to a JSON string and be read as a block with no keys, so such a call is rejected when compiling.

getExampleJson() [2/3]

static json inp::BCBaseDeck::getExampleJson ( const json &  given = json::object(), const geom::GeomData *  region = nullptr  )

inlinestatic

Returns example JSON object for ModelDeck configuration.

Returns

JSON object with example configuration

Returns the block with the given fields set

Type selects what the block may carry rather than appearing in it: a set of initial conditions takes IC_Type and IC_Vector, any other takes Direction and Zero_Displacement. A region is given as a geometry rather than as a key, so it is a parameter of its own; leaving it out means the set applies everywhere.

Parameters

given	Field names and values to set, checked against the table
region	Geometry the set is restricted to, or nothing

Returns

JSON object for this deck

Definition at line 233 of file bcBaseDeck.h.

                                                                     {
      const std::vector<std::string> extra = {
          "Type", "Time_Function", "Spatial_Function", "IC_Type", "IC_Vector"};
      checkKeys(given, fields(), extra);
 
      const auto type = given.value("Type", std::string("Force_BC"));
 
      auto j = json({});
 
      if (region != nullptr) {
        auto j_geom = json({});
        geom::writeGeometry(j_geom, *region);
        // Must be an object: readFromJson does j.at("Region").at("Geometry").
        j["Region"] = json{{"Geometry", j_geom}};
      }
 
      json fieldsGiven =
          json{{"Particle_List",
                given.value("Particle_List", std::vector<size_t>())},
               {"Particle_Exclude_List",
                given.value("Particle_Exclude_List", std::vector<size_t>())}};
      if (type != "IC") {
        fieldsGiven["Direction"] =
            given.value("Direction", std::vector<size_t>());
        fieldsGiven["Zero_Displacement"] =
            given.value("Zero_Displacement", false);
      }
      j.update(applyGiven(fieldsGiven, fields()));
 
      if (given.find("Time_Function") != given.end())
        j["Time_Function"] =
            applyGiven(given.at("Time_Function"), timeFunctionFields());
 
      if (given.find("Spatial_Function") != given.end())
        j["Spatial_Function"] =
            applyGiven(given.at("Spatial_Function"), spatialFunctionFields());
 
      if (type == "IC") {
        const auto icType = given.value("IC_Type", std::string());
        if (icType == "Constant_Velocity")
          j[icType]["Velocity_Vector"] =
              given.value("IC_Vector", std::vector<double>());
      }
 
      return j;
    }

References inp::applyGiven(), inp::checkKeys(), fields(), spatialFunctionFields(), timeFunctionFields(), and geom::writeGeometry().

Referenced by anonymous_namespace{main.cpp}::buildInputJson(), anonymous_namespace{main.cpp}::buildInputJson(), anonymous_namespace{main.cpp}::buildInputJson(), anonymous_namespace{main.cpp}::buildInputJson(), anonymous_namespace{main.cpp}::buildInputJson(), anonymous_namespace{main.cpp}::buildInputJson(), getInputJson(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

Here is the call graph for this function:

Here is the caller graph for this function:

getExampleJson() [3/3]

static json inp::BCBaseDeck::getExampleJson ( const std::string &  )

staticdelete

Rejects a value given where a set of named values is expected.

A type passed on its own would convert to a JSON string and be read as a block with no keys, so such a call is rejected when compiling.

print()

void inp::BCBaseDeck::print ( int  nt = 0, int  lvl = 0  ) const

inline

Prints the information about the object.

Parameters

nt	Number of tabs to append before printing
lvl	Information level (higher means more information)

Definition at line 384 of file bcBaseDeck.h.

{ std::cout << printStr(nt, lvl); }

References printStr().

Here is the call graph for this function:

printStr()

std::string inp::BCBaseDeck::printStr ( int  nt = 0, int  lvl = 0  ) const

inline

Returns the string containing printable information about the object.

Parameters

nt	Number of tabs to append before printing
lvl	Information level (higher means more information)

Returns

string String containing printable information about the object

Definition at line 347 of file bcBaseDeck.h.

                                                      {
 
      auto tabS = util::io::getTabS(nt);
      std::ostringstream oss;
      oss << tabS << "------- BCBaseDeck --------" << std::endl << std::endl;
      oss << tabS << "Selection type  = " << d_selectionType << std::endl;
      oss << tabS << "Is region active  = " << d_isRegionActive << std::endl;
      if (d_regionGeomData.d_geom_p != nullptr) {
        oss << tabS << "Region geometry info: " << std::endl;
        oss << d_regionGeomData.printStr(nt + 1, lvl);
      }
      if (!d_pList.empty())
        oss << tabS << "Particle list = ["
            << util::io::printStr<size_t>(d_pList, 0) << "]" << std::endl;
      if (!d_pNotList.empty())
        oss << tabS << "Particle excluded list = ["
            << util::io::printStr<size_t>(d_pNotList, 0) << "]" << std::endl;
      oss << tabS << "Time function type = " << d_timeFnType << std::endl;
      oss << tabS << "Time function parameters = ["
          << util::io::printStr<double>(d_timeFnParams, 0) << "]" << std::endl;
      oss << tabS << "Spatial function type = " << d_spatialFnType << std::endl;
      oss << tabS << "Spatial function parameters = ["
          << util::io::printStr<double>(d_spatialFnParams, 0) << "]" << std::endl;
      oss << tabS << "Direction = [" << util::io::printStr<size_t>(d_direction, 0)
          << "]" << std::endl;
      oss << tabS << "Is displacement zero = " << d_isDisplacementZero << std::endl;
      oss << tabS << std::endl;
 
      return oss.str();
    }

References d_direction, geom::GeomData::d_geom_p, d_isDisplacementZero, d_isRegionActive, d_pList, d_pNotList, d_regionGeomData, d_selectionType, d_spatialFnParams, d_spatialFnType, d_timeFnParams, d_timeFnType, util::io::getTabS(), and geom::GeomData::printStr().

Referenced by print().

Here is the call graph for this function:

Here is the caller graph for this function:

readFromJson()

void inp::BCBaseDeck::readFromJson ( const json &  j, std::string  type  )

inline

Reads from json object.

Definition at line 294 of file bcBaseDeck.h.

                                                     {
      if (j.empty())
        return;
 
      // fix selection type
      if (j.find("Region") != j.end()) {
        d_selectionType = "region";
        d_isRegionActive = true;
        if (j.find("Particle_List") != j.end())
          d_selectionType += "_with_include_list";
 
        if (j.find("Particle_Exclude_List") != j.end())
          d_selectionType += "_with_exclude_list";
      } else {
        d_isRegionActive = false;
        if (j.find("Particle_List") != j.end())
          d_selectionType = "particle";
      }
 
      if (d_isRegionActive) {
        geom::readGeometry(j.at("Region").at("Geometry"), d_regionGeomData);
        // create a geometry object based on the data
        geom::createGeomObject(d_regionGeomData);
      }
 
      readFields(*this, j, fields());
 
      if (j.find("Time_Function") != j.end())
        readFields(*this, j.at("Time_Function"), timeFunctionFields());
 
      if (j.find("Spatial_Function") != j.end())
        readFields(*this, j.at("Spatial_Function"), spatialFunctionFields());
 
      if (type != "IC" && j.find("Direction") == j.end())
        throw std::runtime_error(
            "Direction must be specified for boundary condition");
 
      // if it is initial condition
      if (type == "IC") {
        if (j.find("Constant_Velocity") != j.end()) {
          d_icType = "Constant_Velocity";
          d_icVec = util::Point(j.at("Constant_Velocity").value("Velocity_Vector", std::vector<double>({0., 0., 0.})));
        }
      }
    }

References geom::createGeomObject(), d_icType, d_icVec, d_isRegionActive, d_regionGeomData, d_selectionType, fields(), inp::readFields(), geom::readGeometry(), spatialFunctionFields(), and timeFunctionFields().

Referenced by inp::BCDeck::readFromJson(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

Here is the call graph for this function:

Here is the caller graph for this function:

spatialFunctionFields()

static const std::vector< Field< BCBaseDeck > > & inp::BCBaseDeck::spatialFunctionFields ( )

inlinestatic

The fields of the Spatial_Function sub-block.

Returns

fields The field table

Definition at line 204 of file bcBaseDeck.h.

                                                                       {
      static const std::vector<Field<BCBaseDeck>> f = {
          field(&BCBaseDeck::d_spatialFnType, "Type", std::string(),
                "Spatial dependence of the condition"),
          field<BCBaseDeck, std::vector<double>>(
              &BCBaseDeck::d_spatialFnParams, "Parameters", {},
              "Parameters of the spatial dependence", {},
              [](const std::vector<double> &v) { return !v.empty(); }),
      };
      return f;
    }

References d_spatialFnParams, d_spatialFnType, and inp::field().

Referenced by getExampleJson(), and readFromJson().

Here is the call graph for this function:

Here is the caller graph for this function:

timeFunctionFields()

static const std::vector< Field< BCBaseDeck > > & inp::BCBaseDeck::timeFunctionFields ( )

inlinestatic

The fields of the Time_Function sub-block.

Returns

fields The field table

Definition at line 188 of file bcBaseDeck.h.

                                                                    {
      static const std::vector<Field<BCBaseDeck>> f = {
          field(&BCBaseDeck::d_timeFnType, "Type", std::string(),
                "Time dependence of the condition"),
          field<BCBaseDeck, std::vector<double>>(
              &BCBaseDeck::d_timeFnParams, "Parameters", {},
              "Parameters of the time dependence", {},
              [](const std::vector<double> &v) { return !v.empty(); }),
      };
      return f;
    }

References d_timeFnParams, d_timeFnType, and inp::field().

Referenced by getExampleJson(), and readFromJson().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

d_direction

std::vector<size_t> inp::BCBaseDeck::d_direction

List of dofs on which this bc will be applied.

E.g. if bc is only applied on x-component, d_direction will be 1. If bc is applied on x- and y-component, d_direction will be vector with elements 1 and 2.

Definition at line 90 of file bcBaseDeck.h.

Referenced by fields(), printStr(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

d_icType

std::string inp::BCBaseDeck::d_icType

Type.

Definition at line 102 of file bcBaseDeck.h.

Referenced by readFromJson(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

d_icVec

util::Point inp::BCBaseDeck::d_icVec

Initial velocity vector.

Definition at line 105 of file bcBaseDeck.h.

Referenced by readFromJson(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

d_isDisplacementZero

bool inp::BCBaseDeck::d_isDisplacementZero

Specify if this bc corresponds to zero displacement condition.

Definition at line 99 of file bcBaseDeck.h.

Referenced by fields(), printStr(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

d_isRegionActive

bool inp::BCBaseDeck::d_isRegionActive

Flag that indicates if region-based application of boundary condition is active. So cases of 'region', 'region_with_include_list', 'region_with_exclude_list', and 'region_with_include_list_with_exclude_list' will have region-based application of boundary condition.

Definition at line 46 of file bcBaseDeck.h.

Referenced by BCBaseDeck(), loading::needToComputeDof(), printStr(), readFromJson(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

d_pList

std::vector<size_t> inp::BCBaseDeck::d_pList

List of particles (if any)

Definition at line 52 of file bcBaseDeck.h.

Referenced by BCBaseDeck(), fields(), loading::needToComputeDof(), loading::needToProcessParticle(), printStr(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

d_pNotList

std::vector<size_t> inp::BCBaseDeck::d_pNotList

List of particles to not include (if any)

Definition at line 55 of file bcBaseDeck.h.

Referenced by BCBaseDeck(), fields(), loading::needToComputeDof(), loading::needToProcessParticle(), printStr(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

d_regionGeomData

geom::GeomData inp::BCBaseDeck::d_regionGeomData

Region geometry (if any)

Definition at line 49 of file bcBaseDeck.h.

Referenced by BCBaseDeck(), loading::needToComputeDof(), printStr(), readFromJson(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

d_selectionType

std::string inp::BCBaseDeck::d_selectionType

Method for applying force e.g.

• particle: provides global id of particle to which force should be applied
• wall: provides global id of wall to which force should be applied
• region: provides area within which all nodes of any particle will get this force

Definition at line 39 of file bcBaseDeck.h.

Referenced by BCBaseDeck(), loading::needToComputeDof(), loading::needToProcessParticle(), printStr(), and readFromJson().

d_spatialFnParams

std::vector<double> inp::BCBaseDeck::d_spatialFnParams

List of parameters for function wrt spatial coordinate.

Definition at line 96 of file bcBaseDeck.h.

Referenced by printStr(), and spatialFunctionFields().

d_spatialFnType

std::string inp::BCBaseDeck::d_spatialFnType

Name of the formula of with respect to spatial coordinate.

List of allowed values are:

• "" (none)
• constant
• hat_x
• hat_y
• sin
• rotation

Definition at line 81 of file bcBaseDeck.h.

Referenced by printStr(), spatialFunctionFields(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

d_timeFnParams

std::vector<double> inp::BCBaseDeck::d_timeFnParams

List of parameters for function wrt time.

Definition at line 93 of file bcBaseDeck.h.

Referenced by printStr(), anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck(), and timeFunctionFields().

d_timeFnType

std::string inp::BCBaseDeck::d_timeFnType

Name of the formula with respect to time.

List of allowed values are:

• "" (none)
• constant
• linear
• linear_step
• linear_slow_fast
• rotation

Definition at line 68 of file bcBaseDeck.h.

Referenced by printStr(), anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck(), and timeFunctionFields().

d_type

std::string inp::BCBaseDeck::d_type

Method for applying force. E.g., Force_BC, Displacement_BC, IC.

Definition at line 28 of file bcBaseDeck.h.

---

The documentation for this struct was generated from the following file:

• /home/user/project/src/inp/bcBaseDeck.h