def __init__(self, name=None):
        Script.__init__(self, name)
        DynamicComponentHarness.__init__(self)

        self.client = ""

        return

  def __init__(self, name="simpledbqueryapp"):
    """
    Constructor.
    """
    Script.__init__(self, name)

    # Database information
    self.numLocs = None
    self.spaceDim = None
    self.numVals = None
    self.dataDim = None
    self.dbCoords = None
    self.dbData = None
    self.names = None
    self.units = None

    # Query information
    self.numPts = None
    self.coords = None
    self.dist2 = None
    self.area = None
    self.areaDir = None
    self.volume = None

    return

 def _configure(self):
   """
   Set members using inventory.
   """
   Script._configure(self)
   self.data = self.inventory.data
   return

        def _init(self):
            Script._init(self)

            import pyre.db
            self.db = pyre.db.connect(self.inventory.db)

            return

  def __init__(self, name="quadratureapp"):
    """
    Constructor.
    """
    Script.__init__(self, name)

    # Mesh information
    self.spaceDim = None
    self.cellDim = None
    self.numVertices = None
    self.numCells = None
    self.vertices = None
    self.cells = None

    # Reference cell information
    self.numBasis = None
    self.numQuadPts = None
    self.verticesRef = None
    self.quadPtsRef = None
    self.quadWts = None
    self.basis = None
    self.basisDerivRef = None
    self.basisDeriv = None

    # Computed quadrature information
    self.quadPts = None
    self.jacobian = None
    self.jacobianDet = None
    self.jacobianInv = None
    return

 def __init__(self, name="unittestapp", petsc_options=[("malloc_dump", "true")]):
   """
   Constructor.
   """
   Script.__init__(self, name)
   self.petscOptions = petsc_options
   return

 def __init__(self):
     Script.__init__(self, 'derunapp')
     self.scale = ''
     self.probability = ''
     self.mod = ''
     self.strategy = ''
     self.solution = None
     return

    def __init__(self, name=None):
        if name is None:
            name = 'sample'
            
        Script.__init__(self, name)
        ComponentHarness.__init__(self)

        return

 def _configure(self):
   """
   Setup members based on inventory.
   """
   Script._configure(self)
   self.geometry = self.inventory.geometry
   self.values = self.inventory.values
   self.iohandler = self.inventory.iohandler
   return

    def __init__(self, name, asCGI=None):
        Script.__init__(self, name)
        self.stream = None

        if asCGI is None:
            asCGI = True
        self.asCGIScript(asCGI)
        
        return

 def _configure(self):
   """
   Set members using inventory.
   """
   Script._configure(self)
   self.data = self.inventory.data
   self.mesh = self.inventory.mesh
   self.quadrature = self.inventory.quadrature
   return

 def _configure(self):
     Script._configure(self)
     self.name = self.inventory.name
     self.unitcell_path = self.inventory.unitcell
     self.ecutoff = self.inventory.ecutoff
     self.xcf  = self.inventory.xcf
     self.mpmesh = self.inventory.mpmesh
     self.generateInputsOnly = self.inventory.generateInputsOnly
     self.cmd = self.inventory.cmd
     return

 def _configure(self):
     from mystic import strategy as detools
     Script._configure(self)
     mod = __import__(self.inventory.inputs)
     self.mod = mod
    
     if self.inventory.verbose:
         logging.basicConfig(level=logging.DEBUG,
                             format='%(asctime)s %(levelname)s %(message)s',
                             datefmt='%a, %d %b %Y %H:%M:%S')

 def _configure(self):
   """
   Set members using inventory.
   """
   Script._configure(self)
   self.data = self.inventory.data
   self.mesh = self.inventory.mesh
   self.quadrature = self.inventory.quadrature
   self.material = self.inventory.material
   self.solution = self.inventory.solution
   return

    def _configure(self):
        Script._configure(self)

        for param in self.parameters:
            exec "self.%s = self.inventory.%s" % (param, param)
            continue

        self.C_ms = numpy.array(eval(self.C_ms))
        # it seems that it works better to make viewDirectory equal to outputDir
        self.outputDir = self.viewDirectory
        return

  def __init__(self, name="slip_invert"):
    Application.__init__(self, name)

    self.dataCoords = None
    self.dataVals = None
    self.dataCov = None
    self.dataNames = []
    self.numDataPoints = 0
    self.numDesignRows = 0

    self.numFaultVerts = 0
    self.numFaultCells = 0
    self.faultVertCoords = None
    self.faultCells = None

    self.numImpulses = 0
    self.impulseInds = None
    self.impulseCoords = None

    self.summaryHead = 'Penalty-weight\tData-residual\t' + \
                       'Weighted-data-residual\tPenalty-residual\t' + \
                       'Weighted-penalty-residual\tTotal-residual\t' + \
                       'Total-weighted-residual'
    self.numSummaryCols = 7

    self.design = None

    return

  def _configure(self):
    """
    Setup members using inventory.
    """
    Application._configure(self)
    # import pdb
    # pdb.set_trace()

    # File info.
    self.vtkInputFile = self.inventory.vtkInputFile
    self.vtkOutputFile = self.inventory.vtkOutputFile

    # Index information
    self.tensorIndex = self.inventory.tensorIndex
    self.tensorComponentsOrder = self.inventory.tensorComponentsOrder

    # Parameters
    self.frictionAngle = self.inventory.frictionAngle.value
    self.cohesion = self.inventory.cohesion.value
    sinFric = math.sin(self.frictionAngle)
    cosFric = math.cos(self.frictionAngle)
    denomFriction = math.sqrt(3.0) * (3.0 - sinFric)
    self.alphaYield = 2.0 * sinFric/denomFriction
    self.beta = 6.0 * self.cohesion * cosFric/denomFriction

    return

  def _configure(self):
    """
    Setup members using inventory.
    """
    Application._configure(self)
    self.elasThick = self.inventory.elasThick
    self.lockDepth = self.inventory.lockDepth
    self.recurrenceTime = self.inventory.recurrenceTime
    self.viscosity = self.inventory.viscosity
    self.shearModulus = self.inventory.shearModulus
    self.velocity = self.inventory.plateVelocity / 2.0
    self.numberCycles = self.inventory.numberCycles
    self.numberSteps = self.inventory.numberSteps
    self.numberTerms = self.inventory.numberTerms
    self.numberPoints = self.inventory.numberPoints
    self.deltaX = self.inventory.deltaX
    self.xEpsilon = self.inventory.xEpsilon

    self.outputDisp = self.inventory.outputDisp
    self.outputVel = self.inventory.outputVel
    self.dispFilename = self.inventory.dispFilename
    self.velFilename = self.inventory.velFilename

    self.deltaT = self.recurrenceTime / self.numberSteps
    self.tauFac = 0.5 * self.shearModulus / self.viscosity
    self.tau0 = self.recurrenceTime * self.tauFac

    return

  def _configure(self):
    """
    Setup members using inventory.
    """
    Application._configure(self)

    return

  def _configure(self):
    """
    Setup members using inventory.
    """
    Application._configure(self)
    self.dataDim = self.inventory.dataDim
    self.pointsFile = self.inventory.pointsFile
    self.segsFile = self.inventory.segsFile
    self.slipScale = self.inventory.slipScale
    self.spaceDim = 3
    self.pointsSpatialDB = self.inventory.pointsSpatialDB
    self.upDir = self.inventory.upDir
    self.normalDir = self.inventory.normalDir
    self.dipSlip = self.inventory.dipSlip
    self.dipCutoff = self.inventory.dipCutoff
    self.xMinVal = self.inventory.xMin.value
    self.xMaxVal = self.inventory.xMax.value
    self.yMinVal = self.inventory.yMin.value
    self.yMaxVal = self.inventory.yMax.value
    self.zMinVal = self.inventory.zMin.value
    self.zMaxVal = self.inventory.zMax.value
    self.defaultValues = self.inventory.defaultValues

    self.upVec = numpy.array([float(self.upDir[0]), float(self.upDir[1]),
                              float(self.upDir[2])], dtype=numpy.float64)

    self.normalVec = numpy.array([float(self.normalDir[0]),
                                  float(self.normalDir[1]),
                                  float(self.normalDir[2])], dtype=numpy.float64)

    self.dipCutoffProj = abs(math.sin(self.dipCutoff.value))

    return