FLAC FISH Index

Below is a listing of the FISH functions that are specific to FLAC. See the global FISH Index for all functions available to FLAC.

Table 1: FLAC FISH Functions by Group*

c zone functions     includes:	c struct (structure)     includes:
c attach functions	c beam functions
c face functions	c cable functions
c field (zone field data)	c geogrid functions
c gp (gridpoint) functions	c link functions
c interface functions	c liner functions
c interface.elem functions	c node functions
c interface.node functions	c pile functions
c tet (zone tetra) functions	c shell functions
sketch
c block functions
c edge functions
c mesh functions
c point functions
c segment functions
c set functions

*These functions are used by FLAC2D and FLAC3D

Table 2: FLAC3D-specific FISH Functions by Group

building_blocks
c block functions	c edge functions
c face functions	c point functions
c set functions

All groups of FISH functions available in FLAC are listed alphabetically by group name below.

---

building_blocks.block functions

building_blocks.block.ablock(BB_BLOCK_PNT,BB_FACE_PNT)

building_blocks.block.center(BB_BLOCK_PNT)

building_blocks.block.check(BB_BLOCK_PNT)

building_blocks.block.edge(BB_BLOCK_PNT,INT)

building_blocks.block.face(BB_BLOCK_PNT,INT)

building_blocks.block.group(BB_BLOCK_PNT<,STR/IND>)

building_blocks.block.group.remove(BB_BLOCK_PNT,STR/IND<,STR/IND>)

building_blocks.block.isgroup(BB_BLOCK_PNT,STR/IND<,STR/IND>)

building_blocks.block.multiplier(BB_BLOCK_PNT)

building_blocks.block.point(BB_BLOCK_PNT,INT)

building_blocks.block.size(BB_BLOCK_PNT)

building_blocks.edge functions

building_blocks.edge.center(BB_EDGE_PNT)

building_blocks.edge.cp.add(BB_EDGE_PNT,VEC)

building_blocks.edge.cp.delete(BB_EDGE_PNT,INT)

building_blocks.edge.cp.localu(BB_EDGE_PNT,INT)

building_blocks.edge.cp.point(BB_EDGE_PNT,INT)

building_blocks.edge.cp.size(BB_EDGE_PNT)

building_blocks.edge.curve(BB_EDGE_PNT)

building_blocks.edge.direction(BB_EDGE_PNT)

building_blocks.edge.grid.ratio(BB_EDGE_PNT)

building_blocks.edge.grid.ratio.isolate(BB_EDGE_PNT)

building_blocks.edge.grid.size(BB_EDGE_PNT)

building_blocks.edge.group(BB_EDGE_PNT<,STR/IND>)

building_blocks.edge.group.remove(BB_EDGE_PNT,STR/IND<,STR/IND>)

building_blocks.edge.length(BB_EDGE_PNT)

building_blocks.edge.next.edge(BB_EDGE_PNT,INT)

building_blocks.edge.next.index(BB_EDGE_PNT,INT)

building_blocks.edge.point(BB_EDGE_PNT,INT)

building_blocks.edge.start.face(BB_EDGE_PNT)

building_blocks.edge.start.index(BB_EDGE_PNT)

building_blocks.edge.toglobal(BB_EDGE_PNT,FLT)

building_blocks.edge.tolocal(BB_EDGE_PNT,VEC)

building_blocks.edge.type(BB_EDGE_PNT)

building_blocks.face functions

building_blocks.face.area(BB_FACE_PNT)

building_blocks.face.center(BB_FACE_PNT)

building_blocks.face.check(BB_FACE_PNT)

building_blocks.face.edge(BB_FACE_PNT,INT)

building_blocks.face.flip(BB_FACE_PNT,INT)

building_blocks.face.gridsizei(BB_FACE_PNT,BB_BLOCK_PNT)

building_blocks.face.gridsizej(BB_FACE_PNT,BB_BLOCK_PNT)

building_blocks.face.group(BB_FACE_PNT<,STR/IND>)

building_blocks.face.group.remove(BB_FACE_PNT,STR/IND<,STR/IND>)

building_blocks.face.isgroup(BB_FACE_PNT,STR/IND<,STR/IND>)

building_blocks.face.next.face(BB_FACE_PNT,INT)

building_blocks.face.next.index(BB_FACE_PNT,INT)

building_blocks.face.point(BB_FACE_PNT,INT)

building_blocks.face.size(BB_FACE_PNT)

building_blocks.face.toglobal(BB_FACE_PNT,VEC)

building_blocks.face.tolocal(BB_FACE_PNT,VEC)

building_blocks.point functions

building_blocks.point.group(BB_POINT_PNT<,STR/IND>)

building_blocks.point.group.remove(BB_POINT_PNT,STR/IND<,STR/IND>)

building_blocks.point.isgroup(BB_POINT_PNT,STR/IND<,STR/IND>)

building_blocks.point.pos(BB_POINT_PNT)

building_blocks.point.start.edge(BB_POINT_PNT)

building_blocks.point.start.index(BB_POINT_PNT)

building_blocks.set functions

building_blocks.set.block.create(BB_SET_PNT,STR,VEC,VEC,VEC,VEC<,VEC><,VEC><,VEC><,VEC>)

building_blocks.set.block.find(BB_SET_PNT,INT)

building_blocks.set.block.list(BB_SET_PNT)

building_blocks.set.block.remove(BB_SET_PNT,BB_BLOCK_PNT)

building_blocks.set.block.size(BB_SET_PNT)

building_blocks.set.create(STR<,INT>)

building_blocks.set.delete(BB_SET_PNT)

building_blocks.set.edge.find(BB_SET_PNT,INT)

building_blocks.set.edge.list(BB_SET_PNT)

building_blocks.set.edge.near(BB_SET_PNT,VEC<,FLT>)

building_blocks.set.edge.size(BB_SET_PNT)

building_blocks.set.face.find(BB_SET_PNT,INT)

building_blocks.set.face.list(BB_SET_PNT)

building_blocks.set.face.near(BB_SET_PNT,VEC<,FLT>)

building_blocks.set.face.size(BB_SET_PNT)

building_blocks.set.find(INT/STR)

building_blocks.set.id(BB_SET_PNT)

building_blocks.set.list

building_blocks.set.name(BB_SET_PNT)

building_blocks.set.point.find(BB_SET_PNT,INT)

building_blocks.set.point.list(BB_SET_PNT)

building_blocks.set.point.near(BB_SET_PNT,VEC<,FLT>)

building_blocks.set.point.size(BB_SET_PNT)

sketch.block functions

sketch.block.area(EXT_BLOCK_PNT)

sketch.block.block(EXT_BLOCK_PNT,INT)

sketch.block.center(EXT_BLOCK_PNT)

sketch.block.check(EXT_BLOCK_PNT)

sketch.block.countzones(EXT_BLOCK_PNT)

sketch.block.edge(EXT_BLOCK_PNT,INT)

sketch.block.extra(EXT_BLOCK_PNT<,INT>)

sketch.block.find(EXT_SET_PNT,INT)

sketch.block.flip(EXT_BLOCK_PNT,INT)

sketch.block.grid.pos(EXT_BLOCK_PNT,INT,INT)

sketch.block.group(EXT_BLOCK_PNT<,STR/IND>)

sketch.block.group.remove(EXT_BLOCK_PNT,STR/IND<,STR/IND>)

sketch.block.id(EXT_BLOCK_PNT)

sketch.block.irregular.typeid

sketch.block.isgroup(EXT_BLOCK_PNT,STR/IND<,STR/IND>)

sketch.block.list(EXT_SET_PNT)

sketch.block.maxid(EXT_SET_PNT)

sketch.block.multiplier(EXT_BLOCK_PNT)

sketch.block.next.block(EXT_BLOCK_PNT,INT)

sketch.block.next.index(EXT_BLOCK_PNT,INT)

sketch.block.nodes(EXT_SET_PNT,EXT_BLOCK_PNT,INT)

sketch.block.num(EXT_SET_PNT)

sketch.block.param.pos(EXT_BLOCK_PNT,FLT,FLT)

sketch.block.point(EXT_BLOCK_PNT,INT)

sketch.block.regular.typeid

sketch.block.size(EXT_BLOCK_PNT)

sketch.block.typeid

sketch.block.zones.i(EXT_BLOCK_PNT)

sketch.block.zones.j(EXT_BLOCK_PNT)

sketch.edge functions

sketch.edge.blocked(EXT_EDGE_PNT)

sketch.edge.blocks(EXT_EDGE_PNT)

sketch.edge.center(EXT_EDGE_PNT)

sketch.edge.curve(EXT_EDGE_PNT)

sketch.edge.direction(EXT_EDGE_PNT)

sketch.edge.extra(EXT_EDGE_PNT<,INT>)

sketch.edge.find(EXT_SET_PNT,INT)

sketch.edge.grid.ratio(EXT_EDGE_PNT)

sketch.edge.grid.ratio.isolate(EXT_EDGE_PNT)

sketch.edge.grid.size(EXT_EDGE_PNT)

sketch.edge.gridpos(EXT_EDGE_PNT,INT)

sketch.edge.group(EXT_EDGE_PNT<,STR/IND>)

sketch.edge.group.remove(EXT_EDGE_PNT,STR/IND<,STR/IND>)

sketch.edge.id(EXT_EDGE_PNT)

sketch.edge.isgroup(EXT_EDGE_PNT,STR/IND<,STR/IND>)

sketch.edge.length(EXT_EDGE_PNT)

sketch.edge.list(EXT_SET_PNT)

sketch.edge.maxid(EXT_SET_PNT)

sketch.edge.next.edge(EXT_EDGE_PNT,INT)

sketch.edge.next.index(EXT_EDGE_PNT,INT)

sketch.edge.num(EXT_SET_PNT)

sketch.edge.parampos(EXT_EDGE_PNT,FLT)

sketch.edge.point(EXT_EDGE_PNT,INT)

sketch.edge.poly.add(EXT_EDGE_PNT,VEC)

sketch.edge.poly.localu(EXT_EDGE_PNT,INT)

sketch.edge.poly.localv(EXT_EDGE_PNT,INT)

sketch.edge.poly.point(EXT_EDGE_PNT,INT)

sketch.edge.poly.remove(EXT_EDGE_PNT,INT)

sketch.edge.poly.size(EXT_EDGE_PNT)

sketch.edge.simple(EXT_EDGE_PNT)

sketch.edge.start.block(EXT_EDGE_PNT)

sketch.edge.start.index(EXT_EDGE_PNT)

sketch.edge.type(EXT_EDGE_PNT)

sketch.edge.typeid

sketch.mesh functions

sketch.point functions

sketch.point.blocks(EXT_POINT_PNT)

sketch.point.edges(EXT_POINT_PNT)

sketch.point.extra(EXT_POINT_PNT<,INT>)

sketch.point.find(EXT_SET_PNT,INT)

sketch.point.group(EXT_POINT_PNT<,STR/IND>)

sketch.point.group.remove(EXT_POINT_PNT,STR/IND<,STR/IND>)

sketch.point.id(EXT_POINT_PNT)

sketch.point.isgroup(EXT_POINT_PNT,STR/IND<,STR/IND>)

sketch.point.list(EXT_SET_PNT)

sketch.point.maxid(EXT_SET_PNT)

sketch.point.num(EXT_SET_PNT)

sketch.point.pos(EXT_POINT_PNT)

sketch.point.start.edge(EXT_POINT_PNT)

sketch.point.start.index(EXT_POINT_PNT)

sketch.point.typeid

sketch.segment functions

sketch.segment.center(EXT_SEGMENT_PNT)

sketch.segment.count(EXT_SET_PNT)

sketch.segment.curve(EXT_SEGMENT_PNT)

sketch.segment.direction(EXT_SEGMENT_PNT)

sketch.segment.extra(EXT_segment_PNT<,INT>)

sketch.segment.find(EXT_SET_PNT,INT)

sketch.segment.find.linear(EXT_SET_PNT,INT)

sketch.segment.grid.ratio(EXT_SEGMENT_PNT)

sketch.segment.grid.size(EXT_SEGMENT_PNT)

sketch.segment.gridpos(EXT_SEGMENT_PNT,INT)

sketch.segment.group(EXT_SEGMENT_PNT<,STR/IND>)

sketch.segment.group.remove(EXT_SEGMENT_PNT,STR/IND<,STR/IND>)

sketch.segment.id(EXT_SEGMENT_PNT)

sketch.segment.isgroup(EXT_SEGMENT_PNT,STR/IND<,STR/IND>)

sketch.segment.length(EXT_SEGMENT_PNT)

sketch.segment.list(EXT_SET_PNT)

sketch.segment.maxid(EXT_SET_PNT)

sketch.segment.next.index(EXT_SEGMENT_PNT,INT)

sketch.segment.next.segment(EXT_SEGMENT_PNT,INT)

sketch.segment.num(EXT_SET_PNT)

sketch.segment.parampos(EXT_SEGMENT_PNT,FLT)

sketch.segment.poly.add(EXT_SEGMENT_PNT,VEC)

sketch.segment.poly.localu(EXT_SEGMENT_PNT,INT)

sketch.segment.poly.localv(EXT_SEGMENT_PNT,INT)

sketch.segment.poly.localw(EXT_SEGMENT_PNT,INT)

sketch.segment.poly.point(EXT_SEGMENT_PNT,INT)

sketch.segment.poly.remove(EXT_SEGMENT_PNT,INT)

sketch.segment.poly.size(EXT_SEGMENT_PNT)

sketch.segment.removegroup(EXT_SEGMENT_PNT,STR/IND<,STR/IND>)

sketch.segment.simple(EXT_SEGMENT_PNT)

sketch.segment.type(EXT_segment_PNT)

sketch.set functions

sketch.set.axis.n(EXT_SET_PNT)

sketch.set.axis.u(EXT_SET_PNT)

sketch.set.axis.v(EXT_SET_PNT)

sketch.set.badzones(EXT_SET_PNT<,BOOL>)

sketch.set.block.create(EXT_SET_PNT,INT,INT,INT<,INT>)

sketch.set.block.delete(EXT_SET_PNT,EXT_BLOCK_PNT)

sketch.set.block.find(EXT_SET_PNT,INT)

sketch.set.block.list(EXT_SET_PNT)

sketch.set.block.near(EXT_SET_PNT,VEC<,FLT>)

sketch.set.block.size(EXT_SET_PNT)

sketch.set.create(STR)

sketch.set.delete(EXT_SET_PNT)

sketch.set.edge.combine(EXT_SET_PNT,EXT_EDGE_PNT,FLT<,FLT>)

sketch.set.edge.create(EXT_SET_PNT,INT,INT)

sketch.set.edge.delete(EXT_SET_PNT,EXT_EDGE_PNT)

sketch.set.edge.find(EXT_SET_PNT,INT)

sketch.set.edge.list(EXT_SET_PNT)

sketch.set.edge.near(EXT_SET_PNT,VEC<,FLT>)

sketch.set.edge.size(EXT_SET_PNT)

sketch.set.find

sketch.set.id(EXT_SET_PNT)

sketch.set.list

sketch.set.metadata.find(EXT_SET_PNT,STR)

sketch.set.metadata.key(EXT_SET_PNT,INT)

sketch.set.metadata.size(EXT_SET_PNT)

sketch.set.metadata.value(EXT_SET_PNT,STR)

sketch.set.name(EXT_SET_PNT)

sketch.set.origin(EXT_SET_PNT)

sketch.set.point.create(EXT_SET_PNT,VEC)

sketch.set.point.delete(EXT_SET_PNT,EXT_POINT_PNT)

sketch.set.point.find(EXT_SET_PNT,INT)

sketch.set.point.list(EXT_SET_PNT)

sketch.set.point.near(EXT_SET_PNT,V2<,FLT>)

sketch.set.point.size(EXT_SET_PNT)

sketch.set.region.element.num(EXT_SET_PNT,INT)

sketch.set.region.nodes(EXT_SET_PNT<,INT><,INT>)

sketch.set.set.un(EXT_SET_PNT,VEC,VEC)

sketch.set.set.uv(EXT_SET_PNT,VEC,VEC)

sketch.set.set.vn(EXT_SET_PNT,VEC,VEC)

sketch.set.zone.count2(EXT_SET_PNT)

sketch.set.zone.count3(EXT_SET_PNT)

sketch.set.zone.target.autodir(EXT_SET_PNT)

sketch.set.zone.target.edge(EXT_SET_PNT)

sketch.set.zone.target.size(EXT_SET_PNT)

sketch.set.zone.target.total(EXT_SET_PNT)

struct (structure) functions

struct.connectivity(STRUCT_PNT,INT)

struct.delete(STRUCT_PNT)

struct.density(STRUCT_PNT)

struct.extra(STRUCT_PNT<,INT>)

struct.find(INT)

struct.force.nodal(STRUCT_BEAM_PNT)

struct.force.nodal.local(STRUCT_BEAM_PNT)

struct.force.update

struct.head

struct.id(STRUCT_PNT)

struct.id.component(STRUCT_PNT)

struct.list

struct.local.system(STRUCT_PNT<,INT><,INT>)

struct.mark(STRUCT_PNT)

struct.maxid

struct.mech.convergence

struct.mech.ratio.avg

struct.mech.ratio.local

struct.mech.ratio.max

struct.near(VEC+)

struct.next(STRUCT_PNT)

struct.node(STRUCT_PNT,INT)

struct.num

struct.pos(STRUCT_PNT)

struct.prop(STRUCT_PNT,STR/INT)

struct.prop.index(STRUCT_PNT,STR)

struct.shell.prop(STRUCT_PNT,STR/INT)

struct.therm.expansion(STRUCT_PNT)

struct.type(STRUCT_PNT)

struct.typeid

struct.was.updated

struct.beam functions

struct.beam.element.type(STRUCT_BEAM_PNT)

struct.beam.force(STRUCT_BEAM_PNT,INT)

struct.beam.length(STRUCT_BEAM_PNT)

struct.beam.load(STRUCT_BEAM_PNT)

struct.beam.model(STRUCT_BEAM_PNT)

struct.beam.moment(STRUCT_BEAM_PNT,INT)

struct.beam.plastic(STRUCT_BEAM_PNT)(currently 3D ONLY)

struct.beam.plastic.iplocation(STRUCT_BEAM_PNT,INT)(currently 3D ONLY)

struct.beam.plastic.ipstate(STRUCT_BEAM_PNT,INT)(currently 3D ONLY)

struct.beam.plastic.ipstress(STRUCT_BEAM_PNT,INT)(currently 3D ONLY)

struct.beam.plastic.stress.bounds(STRUCT_BEAM_PNT)(currently 3D ONLY)

struct.beam.prop(STRUCT_PNT,STR/INT)

struct.beam.prop.index(STRUCT_PNT,STR<,INT>)

struct.beam.volume(STRUCT_BEAM_PNT)

struct.beam.ydir(STRUCT_BEAM_PNT)

struct.cable functions

struct.cable.force.axial(STRUCT_CABLE_PNT)

struct.cable.grout.confining(STRUCT_CABLE_PNT,INT)

struct.cable.grout.dir(STRUCT_CABLE_PNT,INT)

struct.cable.grout.disp(STRUCT_CABLE_PNT,INT)

struct.cable.grout.slip(STRUCT_CABLE_PNT,INT)

struct.cable.grout.stress(STRUCT_CABLE_PNT,INT)

struct.cable.length(STRUCT_CABLE_PNT)

struct.cable.prop(STRUCT_PNT,STR/INT)

struct.cable.prop.index(STRUCT_PNT,STR<,INT>)

struct.cable.state.compression(STRUCT_CABLE_PNT)

struct.cable.state.tension(STRUCT_CABLE_PNT)

struct.cable.strain.plastic(STRUCT_CABLE_PNT)

struct.cable.stress.axial(STRUCT_CABLE_PNT)

struct.cable.volume(STRUCT_CABLE_PNT)

struct.geogrid functions

struct.geogrid.prop(STRUCT_PNT,STR/INT)

struct.geogrid.prop.index(STRUCT_PNT,STR<,INT>)

struct.geogrid.shear.dir(STRUCT_GEOGRID_PNT,INT)

struct.geogrid.shear.disp(STRUCT_GEOGRID_PNT,INT)

struct.geogrid.shear.state(STRUCT_GEOGRID_PNT,INT)

struct.geogrid.shear.stress(STRUCT_GEOGRID_PNT,INT)

struct.geogrid.stress.confining(STRUCT_GEOGRID_PNT,INT)

struct.link functions

struct.link.attach(STRUCT_LINK_PNT,INT)

struct.link.delete(STRUCT_LINK_PNT)

struct.link.extra(STRUCT_LINK_PNT<,INT>)

struct.link.find(INT)

struct.link.group(STRUCT_LINK_PNT<,STR/IND>)

struct.link.group.remove(STRUCT_LINK_PNT,STR/IND<,STR/IND>)

struct.link.head

struct.link.id(STRUCT_LINK_PNT)

struct.link.id.component(STRUCT_LINK_PNT)

struct.link.isgroup(STRUCT_LINK_PNT,STR/IND<,STR/IND>)

struct.link.list

struct.link.maxid

struct.link.model(STRUCT_LINK_PNT,INT)

struct.link.model.area(STRUCT_LINK_PNT<,INT>)

struct.link.model.compression(STRUCT_LINK_PNT<,INT>)

struct.link.model.disp(STRUCT_LINK_PNT<,INT>)

struct.link.model.force(STRUCT_LINK_PNT<,INT>)

struct.link.model.gap(STRUCT_LINK_PNT)

struct.link.model.gap.neg(STRUCT_LINK_PNT<,INT>)

struct.link.model.gap.pos(STRUCT_LINK_PNT<,INT>)

struct.link.model.prop(STRUCT_LINK_PNT,INT,STR)

struct.link.model.stiffness(STRUCT_LINK_PNT<,INT>)

struct.link.model.tension(STRUCT_LINK_PNT<,INT>)

struct.link.model.yield(STRUCT_LINK_PNT,INT)

struct.link.next(STRUCT_LINK_PNT)

struct.link.node(STRUCT_LINK_PNT)

struct.link.num

struct.link.side(STRUCT_LINK_PNT)

struct.link.slide(STRUCT_LINK_PNT)

struct.link.slide.tol(STRUCT_LINK_PNT)

struct.link.target(STRUCT_LINK_PNT)

struct.link.type(STRUCT_LINK_PNT)

struct.link.typeid

struct.link.used.by(STRUCT_LINK_PNT)

struct.liner functions

struct.liner.embedded(STRUCT_LINER_PNT)

struct.liner.normal.dir(STRUCT_LINER_PNT,INT<,INT>)

struct.liner.normal.disp(STRUCT_LINER_PNT,INT<,INT>)

struct.liner.normal.stress(STRUCT_LINER_PNT,INT<,INT>)

struct.liner.prop(STRUCT_PNT,STR/INT)

struct.liner.prop.index(STRUCT_PNT,STR<,INT>)

struct.liner.shear.dir(STRUCT_LINER_PNT,INT<,INT>)

struct.liner.shear.disp(STRUCT_LINER_PNT,INT<,INT>)

struct.liner.shear.state(STRUCT_LINER_PNT,INT<,INT>)

struct.liner.shear.stress(STRUCT_LINER_PNT,INT<,INT>)

struct.node functions

struct.node.acc.global(STRUCT_NODE_PNT<,INT>)

struct.node.acc.local(STRUCT_NODE_PNT<,INT>)

struct.node.apply(STRUCT_NODE_PNT<,INT>)

struct.node.apply.local(STRUCT_NODE_PNT)

struct.node.convergence(STRUCT_NODE_PNT)

struct.node.damp.local(STRUCT_NODE_PNT)

struct.node.disp.global(STRUCT_NODE_PNT<,INT>)

struct.node.disp.local(STRUCT_NODE_PNT<,INT>)

struct.node.dynamic.timestep(STRUCT_NODE_PNT)

struct.node.elements(STRUCT_NODE_PNT)

struct.node.extra(STRUCT_NODE_PNT<,INT>)

struct.node.find(INT)

struct.node.fix(STRUCT_NODE_PNT,INT)

struct.node.fix.local(STRUCT_NODE_PNT)

struct.node.force.unbal.global(STRUCT_NODE_PNT<,INT>)

struct.node.force.unbal.local(STRUCT_NODE_PNT<,INT>)

struct.node.head

struct.node.id(STRUCT_NODE_PNT)

struct.node.id.component(STRUCT_NODE_PNT)

struct.node.link(STRUCT_NODE_PNT<,INT>)

struct.node.list

struct.node.mark(STRUCT_NODE_PNT)

struct.node.mass.added(STRUCT_NODE_PNT)

struct.node.mass.local(STRUCT_NODE_PNT<,INT>)

struct.node.maxid

struct.node.near(VEC+)

struct.node.next(STRUCT_NODE_PNT)

struct.node.num

struct.node.pos(STRUCT_NODE_PNT)

struct.node.pos.reference(STRUCT_NODE_PNT)

struct.node.ratio(STRUCT_NODE_PNT)

struct.node.ratio.target(STRUCT_NODE_PNT)

struct.node.resultant(STRUCT_NODE_PNT<,INT>)(3D ONLY)

struct.node.stiff.local(STRUCT_NODE_PNT<,INT>)

struct.node.surface.valid(STRUCT_NODE_PNT)(3D ONLY)

struct.node.surface.xdir(STRUCT_NODE_PNT)(3D ONLY)

struct.node.system.local(STRUCT_NODE_PNT<,INT><,INT>)

struct.node.system.surface(STRUCT_NODE_PNT<,INT><,INT>)(3D ONLY)

struct.node.temp.increment(STRUCT_NODE_PNT)

struct.node.typeid

struct.node.vel.global(STRUCT_NODE_PNT<,INT>)

struct.node.vel.local(STRUCT_NODE_PNT<,INT>)

struct.pile functions

struct.pile.gap(STRUCT_PILE_PNT,INT,INT)

struct.pile.normal.dir(STRUCT_PILE_PNT,INT)

struct.pile.normal.disp(STRUCT_PILE_PNT,INT)

struct.pile.normal.state(STRUCT_PILE_PNT,INT)

struct.pile.normal.stress(STRUCT_PILE_PNT,INT)

struct.pile.prop(STRUCT_PNT,STR/INT)

struct.pile.prop.index(STRUCT_PNT,STR<,INT>)

struct.pile.rupture.tension(STRUCT_PILE_PNT)

struct.pile.shear.dir(STRUCT_PILE_PNT,INT)

struct.pile.shear.disp(STRUCT_PILE_PNT,INT)

struct.pile.shear.state(STRUCT_PILE_PNT,INT)

struct.pile.shear.stress(STRUCT_PILE_PNT,INT)

struct.pile.state.compression(STRUCT_PILE_PNT)

struct.pile.state.tension(STRUCT_PILE_PNT)

struct.pile.stress.confining(STRUCT_PILE_PNT,INT)

struct.shell functions

struct.shell.area(STRUCT_SHELL_PNT)

struct.shell.element.type(STRUCT_SHELL_PNT)

struct.shell.model(STRUCT_SHELL_PNT)

struct.shell.plastic(STRUCT_SHELL_PNT)

struct.shell.plastic.idata(STRUCT_SHELL_PNT)

struct.shell.plastic.iplocation(STRUCT_SHELL_PNT,INT)

struct.shell.plastic.ipstate(STRUCT_SHELL_PNT,INT)

struct.shell.plastic.ipstress(STRUCT_SHELL_PNT,INT,INT)

struct.shell.pressure(STRUCT_SHELL_PNT)

struct.shell.prop.index(STRUCT_PNT,STR<,INT>)

struct.shell.resultant(STRUCT_SHELL_PNT,INT<,INT>)

struct.shell.resultant.valid(STRUCT_SHELL_PNT)

struct.shell.stress(STRUCT_SHELL_PNT,INT<,INT>)

struct.shell.stress.bounds(STRUCT_SHELL_PNT)

struct.shell.stress.depth.factor(STRUCT_SHELL_PNT)

struct.shell.stress.prin(STRUCT_SHELL_PNT,INT)

struct.shell.stress.valid(STRUCT_SHELL_PNT)

struct.shell.volume(STRUCT_SHELL_PNT)

zone functions

zone.area(ZONE_PNT)(2D ONLY)

zone.area.deformed(ZONE_PNT)(2D ONLY)

zone.aspect(ZONE_PNT)

zone.bad(ZONE_PNT)(2D ONLY)

zone.code(ZONE_PNT)

zone.condition(ZONE_PNT,INT)

zone.containing(VEC+<,ZONE_PNT>)

zone.copy(ZONE_PNT,ZONE_PNT)

zone.create.gp(STR,LIST)

zone.create.interface.elem(ZONE_PNT,INT,STR)

zone.create.pos(STR,LIST<,FLT>)

zone.create.ratio(FLT,INT,INT)

zone.creep.time.total

zone.creep.timestep

zone.cycle.init(ZONE_PNT)

zone.density(ZONE_PNT)

zone.dynamic.mul(ZONE_PNT)

zone.dynamic.time.total(ZONE_PNT)

zone.dynamic.timestep

zone.extra(ZONE_PNT<,INT>)

zone.find(INT)

zone.flow(ZONE_PNT)

zone.fluid.density(ZONE_PNT)

zone.fluid.model(ZONE_PNT)

zone.fluid.prop(ZONE_PNT,STR)

zone.fluid.prop.index(ZONE_PNT,STR)

zone.fluid.ratio

zone.fluid.stress.normal

zone.fluid.time.total

zone.fluid.unbal.avg

zone.fluid.unbal.max

zone.flux(ZONE_PNT)

zone.force.update

zone.geom.test(ZONE_PNT)

zone.gp(ZONE_PNT<,INT>)

zone.gp.num(ZONE_PNT)

zone.group(ZONE_PNT<,STR/IND>)

zone.group.remove(ZONE_PNT,STR/IND<,STR/IND>)

zone.head

zone.hysteretic(ZONE_PNT,STR)

zone.id(ZONE_PNT)

zone.inbox(VEC,VEC,BOOL)

zone.isgroup(ZONE_PNT,STR/IND<,STR/IND>)

zone.islive(ZONE_PNT)

zone.join(ZONE_PNT,INT)

zone.list(<list>)

zone.maxid

zone.mech.convergence

zone.mech.prop.name(ZONE_PNT,INT)

zone.mech.prop.num(ZONE_PNT)

zone.mech.ratio

zone.mech.ratio.avg

zone.mech.ratio.local

zone.mech.ratio.max

zone.model(ZONE_PNT)

zone.model.init(ZONE_PNT)

zone.near(VEC+)

zone.near.all(VEC+)

zone.near.list(VEC3+,FLT)

zone.near.live(VEC+,BOOL,BOOL,BOOL,STR)

zone.near.map(VEC+,FLT)

zone.next(ZONE_PNT)

zone.num

zone.ortho(ZONE_PNT)

zone.overlays(ZONE_PNT)

zone.planarity(ZONE_PNT)(3D ONLY)

zone.plane.traction(ZONE_PNT,VEC<,ARR_PNT>)

zone.pos(ZONE_PNT)

zone.pp(ZONE_PNT)

zone.prop(ZONE_PNT,STR/INT)

zone.prop.index(ZONE_PNT,STR)

zone.rotation.inc(ZONE_PNT)

zone.rotation.rate(ZONE_PNT)

zone.state(ZONE_PNT)

zone.state.restore(ZONE_PNT)

zone.state.save(ZONE_PNT)

zone.strain.inc(ZONE_PNT)

zone.strain.rate(ZONE_PNT)

zone.strain.shear.inc(ZONE_PNT)

zone.strain.shear.rate(ZONE_PNT)

zone.strain.vol.inc(ZONE_PNT)

zone.strain.vol.rate(ZONE_PNT)

zone.stress(ZONE_PNT)

zone.stress.effective(ZONE_PNT)

zone.stress.int(ZONE_PNT)

zone.stress.max(ZONE_PNT)

zone.stress.min(ZONE_PNT)

zone.stress.prin(ZONE_PNT)

zone.temp(ZONE_PNT)

zone.test.quality(ZONE_PNT,INT)(3D ONLY)

zone.thermal.model(ZONE_PNT)

zone.thermal.prop(ZONE_PNT,STR)

zone.thermal.prop.index(ZONE_PNT,STR)

zone.thermal.ratio

zone.thermal.time.total

zone.typeid

zone.unbal

zone.vol(ZONE_PNT)(3D ONLY)

zone.vol.deformed(ZONE_PNT)(3D ONLY)

zone.was.updated

zone.work.elastic.shear(ZONE_PNT)

zone.work.elastic.total(ZONE_PNT)

zone.work.elastic.vol(ZONE_PNT)

zone.work.plastic.shear(ZONE_PNT)

zone.work.plastic.total(ZONE_PNT)

zone.work.plastic.vol(ZONE_PNT)

attach functions

attach.create(GP_PNT,GP_PNT/ZONE_PNT<,GP_PNT/INT>)

attach.delete(ATTACH_PNT)

attach.extra(ATTACH_PNT<,INT>)

attach.find(INT)

attach.follower(ATTACH_PNT)

attach.group(ATTACH_PNT<,STR/IND>)

attach.group.remove(ATTACH_PNT,STR/IND<,STR/IND>)

attach.id(ATTACH_PNT)

attach.isgroup(ATTACH_PNT,STR/IND<,STR/IND>)

attach.leader(ATTACH_PNT<,INT>)

attach.leader.face(ATTACH_PNT)

attach.leader.zone(ATTACH_PNT)

attach.list

attach.maxid

attach.num

attach.pos(ATTACH_PNT)

attach.snap(ATTACH_PNT)

attach.type(ATTACH_PNT)

attach.typeid

attach.weight.edge(ATTACH_PNT)

attach.weight.face(ATTACH_PNT)

zone.face functions

zone.face.area(ZONE_PNT,INT)(3D ONLY)

zone.face.extra(ZONE_PNT,INT,INT)

zone.face.find(ZONE_PNT,INT/GP_PNT,INT/GP_PNT,INT/GP_PNT)(FLAC3D)

zone.face.find.normal(ZONE_PNT,VEC)

zone.face.gp(ZONE_PNT,INT<,INT>)

zone.face.group(ZONE_PNT,INT<,STR/IND>)

zone.face.group.remove(ZONE_PNT,INT,STR/IND<,STR/IND>)

zone.face.isgroup(ZONE_PNT,INT,STR/IND<,STR/IND>)

zone.face.length(ZONE_PNT,INT)(2D ONLY)

zone.face.normal(ZONE_PNT,INT)

zone.face.pos(ZONE_PNT,INT)

zone.face.size(ZONE_PNT,INT)(3D ONLY)

zone.field functions

zone.field.component

zone.field.extra

zone.field.get(VEC+<,FLT>)

zone.field.get.gp(GP_PNT,ZONE_PNT)

zone.field.gravity

zone.field.hide.fluidnull

zone.field.hide.mechnull

zone.field.hide.thermnull

zone.field.index

zone.field.init

zone.field.log

zone.field.method.index

zone.field.method.name

zone.field.name

zone.field.power

zone.field.prop

zone.field.quantity

zone.field.radius.ratio

zone.field.reset

zone.field.source

zone.field.tol

zone.field.type

zone.field.velocity.limit

gp (gridpoint) functions

gp.accel(GP_PNT)

gp.biot.modulus(GP_PNT)

gp.contacts(GP_PNT)

gp.convergence(GP_PNT)

gp.copy(GP_PNT,GP_PNT)

gp.create(VEC+)

gp.delete(GP_PNT)

gp.disp(GP_PNT)

gp.disp.small(GP_PNT)

gp.dynamic.mul(GP_PNT)

gp.dynamic.timestep(GP_PNT)

gp.extra(GP_PNT<,INT>)

gp.find(INT)

gp.find.name(STR)

gp.fix(GP_PNT)

gp.flow(GP_PNT)

gp.fluid.app(GP_PNT)

gp.fluid.area.inv(GP_PNT)(2D ONLY)

gp.fluid.load(GP_PNT)

gp.fluid.modulus(GP_PNT)

gp.fluid.modulus.confined(GP_PNT)

gp.fluid.tension(GP_PNT)

gp.fluid.unbal(GP_PNT)

gp.fluid.vol.inv(GP_PNT)(3D ONLY)

gp.flux(GP_PNT)

gp.force.app(GP_PNT)

gp.force.load(GP_PNT)

gp.force.unbal(GP_PNT)

gp.force.unbal.add(GP_PNT)

gp.force.unbal.current(GP_PNT)

gp.head

gp.id(GP_PNT)

gp.list(<LIST>)

gp.mass.add(GP_PNT)

gp.mass.gravity(GP_PNT)

gp.mass.inertial(GP_PNT)

gp.maxid

gp.name(GP_PNT)

gp.near(VEC+<,STR>)

gp.near.all(VEC+)

gp.near.live(VEC+,BOOL,BOOL,BOOL,STR)

gp.next(GP_PNT)

gp.num

gp.pos(GP_PNT)

gp.pp(GP_PNT<,INT>)

gp.pp.fix(GP_PNT)

gp.ratio(GP_PNT)

gp.ratio.target(GP_PNT)

gp.sat(GP_PNT)

gp.state.restore(GP_PNT)

gp.state.save(GP_PNT)

gp.stiff(GP_PNT)

gp.system(GP_PNT)

gp.temp(GP_PNT)

gp.temp.app(GP_PNT)

gp.temp.change(GP_PNT)

gp.temp.fix(GP_PNT)

gp.temp.source(GP_PNT)

gp.typeid

gp.vel(GP_PNT)

gp.zones(GP_PNT)

interface functions

interface.find(STR)

interface.group(INTERFACE_PNT<,STR>)

interface.group.remove(INTERFACE_PNT,STR/IND<,STR/IND>)

interface.head

interface.id(INTERFACE_PNT)

interface.isgroup(INTERFACE_PNT,STR/IND<,STR/IND>)

interface.list

interface.name(INTERFACE_PNT)

interface.next(INTERFACE_PNT)

interface.elem functions

interface.elem.area(INTERFACE_ELEM_PNT)(3D ONLY)

interface.elem.extra(INTERFACE_ELEM_PNT<,INT>)

interface.elem.group(INTERFACE_ELEM_PNT<,STR>)

interface.elem.group.remove(INTERFACE_ELEM_PNT,STR/IND<,STR/IND>)

interface.elem.head(INTERFACE_PNT)

interface.elem.host.face(INTERFACE_ELEM_PNT)

interface.elem.host.zone(INTERFACE_ELEM_PNT)

interface.elem.id(INTERFACE_ELEM_PNT)

interface.elem.isgroup(INTERFACE_ELEM_PNT,STR/IND<,STR/IND>)

interface.elem.join(INTERFACE_ELEM_PNT,INT)(3D ONLY)

interface.elem.length(INTERFACE_ELEM_PNT)(2D ONLY)

interface.elem.list(INTERFACE_PNT)

interface.elem.next(INTERFACE_ELEM_PNT)

interface.elem.normal(INTERFACE_ELEM_PNT)

interface.elem.vertex(INTERFACE_ELEM_PNT,INT)

interface.node functions

interface.node.area(INTERFACE_NODE_PNT)(3D ONLY)

interface.node.disp(INTERFACE_NODE_PNT)

interface.node.disp.shear(INTERFACE_NODE_PNT)

interface.node.extra(INTERFACE_NODE_PNT<,INT>)

interface.node.find(INTERFACE_PNT,INT)

interface.node.group(INTERFACE_NODE_PNT<,STR/IND>)

interface.node.group.remove(INTERFACE_NODE_PNT,STR/IND<,STR/IND>)

interface.node.head(INTERFACE_PNT)

interface.node.host.face(INTERFACE_NODE_PNT)

interface.node.host.weight(INTERFACE_NODE_PNT,INT)

interface.node.host.zone(INTERFACE_NODE_PNT)

interface.node.id(INTERFACE_NODE_PNT)

interface.node.isgroup(INTERFACE_NODE_PNT,STR/IND<,STR/IND>)

interface.node.length(INTERFACE_NODE_PNT)(2D ONLY)

interface.node.list(INTERFACE_PNT)

interface.node.near(INTERFACE_PNT,VEC+)

interface.node.next(INTERFACE_NODE_PNT)

interface.node.normal(INTERFACE_NODE_PNT)

interface.node.penetration(INTERFACE_NODE_PNT)

interface.node.pos(INTERFACE_NODE_PNT)

interface.node.pp(INTERFACE_NODE_PNT)

interface.node.prop(INTERFACE_NODE_PNT,STR)

interface.node.slip(INTERFACE_NODE_PNT)

interface.node.state(INTERFACE_NODE_PNT)

interface.node.stress.normal(INTERFACE_NODE_PNT)

interface.node.stress.normal.add(INTERFACE_NODE_PNT)

interface.node.stress.shear(INTERFACE_NODE_PNT)

interface.node.target.face(INTERFACE_NODE_PNT)

interface.node.target.weight(INTERFACE_NODE_PNT,INT)

interface.node.target.zone(INTERFACE_NODE_PNT)

interface.node.tol(INTERFACE_NODE_PNT)

interface.node.vel(INTERFACE_NODE_PNT)

zone.tet (zone tetra) functions

zone.tet.gp(ZONE_PNT<,INT><,INT>)(3D ONLY)

zone.tet.num(ZONE_PNT)(3D ONLY)

zone.tet.smallest.vol(ZONE_PNT,INT)(3D ONLY)

zone.tet.strain.inc(ZONE_PNT<,INT><,INT>)(3D ONLY)

zone.tet.strain.rate(ZONE_PNT<,INT><,INT>)(3D ONLY)

zone.tet.stress(ZONE_PNT<,INT><,INT>)

zone.tet.vol(ZONE_PNT<,INT><,INT>)(3D ONLY)