class ArrayParam:

    def mfouri(self, oper="", coeff="", mode="", isym="", theta="", curve="",
               **kwargs):
        """Calculates the coefficients for, or evaluates, a Fourier series.

        APDL Command: *MFOURI

        Parameters
        ----------
        oper
            Type of Fourier operation:

            Calculate Fourier coefficients COEFF from MODE, ISYM, THETA, and CURVE. - Evaluate the Fourier curve CURVE from COEFF, MODE, ISYM andTHETA

        coeff
            Name of the array parameter vector containing the Fourier
            coefficients (calculated if Oper = FIT, required as input if Oper =
            EVAL).  See *SET for name restrictions.

        mode
            Name of the array parameter vector containing the mode numbers of
            the desired Fourier terms.

        isym
            Name of the array parameter vector containing the symmetry key for
            the corresponding Fourier terms.  The vector should contain keys
            for each term as follows:

            Symmetric (cosine) term - Antisymmetric (sine) term.

        theta, curve
            Names of the array parameter vectors containing the theta vs. curve
            description, respectively.  Theta values should be input in
            degrees.  If Oper = FIT, one curve value should be supplied with
            each theta value.  If Oper = EVAL, one curve value will be
            calculated for each theta value.

        Notes
        -----
        Calculates the coefficients of a Fourier series for a given curve, or
        evaluates the Fourier curve from the given (or previously calculated)
        coefficients.  The lengths of the COEFF, MODE, and ISYM vectors must be
        the same--typically two times the number of modes desired, since two
        terms (sine and cosine) are generally required for each mode.  The
        lengths of the CURVE and THETA vectors should be the same or the
        smaller of the two will be used.  There should be a sufficient number
        of points to adequately define the curve--at least two times the number
        of coefficients.  A starting array element number (1) must be defined
        for each array parameter vector.  The vector specifications *VLEN,
        *VCOL, *VABS, *VFACT, and *VCUM do not apply to this command.  Array
        elements should not be skipped with the *VMASK and the NINC value of
        the *VLEN specifications.  The vector being calculated (COEFF if Oper
        is FIT, or CURVE if Oper is EVAL) must exist as a dimensioned array
        [*DIM].

        This command is valid in any processor.
        """
        command = f"*MFOURI,{oper},{coeff},{mode},{isym},{theta},{curve}"
        return self.run(command, **kwargs)

    def mfun(self, parr="", func="", par1="", **kwargs):
        """Copies or transposes an array parameter matrix.

        APDL Command: *MFUN

        Parameters
        ----------
        parr
            The name of the resulting array parameter matrix.  See *SET for
            name restrictions.

        func
            Copy or transpose function:

            Par1 is copied to ParR - Par1 is transposed to ParR.  Rows (m) and columns (n) of Par1 matrix are
                              transposed to resulting ParR matrix of shape
                              (n,m).

        par1
            Array parameter matrix input to the operation.

        Notes
        -----
        Operates on one input array parameter matrix and produces one output
        array parameter matrix according to:

        ParR = f(Par1)

        where the function (f) is either a copy or transpose, as described
        above.

        Functions are based on the standard FORTRAN definitions where possible.
        ParR may be the same as Par1.  Starting array element numbers must be
        defined for each array parameter matrix if it does not start at the
        first location. For example, *MFUN,A(1,5),COPY,B(2,3) copies matrix B
        (starting at element (2,3)) to matrix A (starting at element (1,5)).
        The diagonal corner elements for each submatrix must be defined: the
        upper left corner by the array starting element (on this command), the
        lower right corner by the current values from the *VCOL and *VLEN
        commands.  The default values are the (1,1) element and the last
        element in the matrix.  No operations progress across matrix planes (in
        the 3rd dimension).  Absolute values and scale factors may be applied
        to all parameters [*VABS, *VFACT].  Results may be cumulative [*VCUM].
        Array elements should not be skipped with the *VMASK and the NINC value
        of the *VLEN specifications.  The number of rows [*VLEN] applies to the
        Par1 array.  See the *VOPER command for details.

        This command is valid in any processor.
        """
        command = f"*MFUN,{parr},{func},{par1}"
        return self.run(command, **kwargs)

    def moper(self, parr="", par1="", oper="", val1="", val2="",
              val3="", val4="", val5="", val6="", **kwargs):
        """ Performs matrix operations on array parameter matrices.

        APDL Command: *MOPER

        Parameters
        ----------
        parr
            The name of the resulting array parameter matrix.  See *SET for
            name restrictions.

        par1
            First array parameter matrix input to the operation. For Oper =
            MAP, this is an N x 3 array of coordinate locations at which to
            interpolate. ParR will then be an N(out) x M array containing the
            interpolated values.

        oper
            Matrix operations:

            INVERT - (*MOPER, ParR, Par1, INVERT)
            Square matrix invert: Inverts the n x n matrix in Par1
            into ParR. The matrix must be well conditioned.

            Warning: Non-independent or ill-conditioned equations can
            cause erroneous results. - For large matrices, use the
            APDL Math operation *LSFACTOR for efficiency (see APDL
            Math).

            MULT - (*MOPER, ParR, Par1, MULT, Par2)
            Matrix multiply: Multiplies Par1 by Par2.  The number of
            rows of Par2 must equal the number of columns of Par1 for
            the operation. If Par2 is input with a number of rows
            greater than the number of columns of Par1, matrices are
            still multiplied. However, the operation only uses a
            number of rows of Par2 equal to the number of columns of
            Par1.

            COVAR - (*MOPER, ParR, Par1, COVAR, Par2)
            Covariance: The measure of association between two columns
            of the input matrix (Par1).  Par1, of size m runs (rows)
            by n data (columns) is first processed to produce a row
            vector containing the mean of each column which is
            transposed to a column vector (Par2) of n array elements.
            The Par1 and Par2 operation then produces a resulting n x
            n matrix (ParR) of covariances (with the variances as the
            diagonal terms).

            CORR - (*MOPER, ParR, Par1, CORR, Par2)
            Correlation: The correlation coefficient between two
            variables.  The input matrix (Par1), of size m runs (rows)
            by n data (columns), is first processed to produce a row
            vector containing the mean of each column which is then
            transposed to a column vector (Par2) of n array elements.
            The Par1 and Par2 operation then produces a resulting n x
            n matrix (ParR) of correlation coefficients (with a value
            of 1.0 for the diagonal terms).

            SOLV - (*MOPER, ParR, Par1, SOLV, Par2)
            Solution of simultaneous equations: Solves the set of n
            equations of n terms of the form an1x1 + an2x2 + ... +
            annxn = bn where Par1 contains the matrix of
            a-coefficients, Par2 the vector(s) of b-values, and ParR
            the vector(s) of x-results.  Par1 must be a square matrix.
            The equations must be linear, independent, and well
            conditioned.

            Warning: Non-independent or ill-conditioned equations can
            cause erroneous results. - For large matrices, use the
            APDL Math operation *LSFACTOR for efficiency (see APDL
            Math).

            SORT - (*MOPER, ParR, Par1, SORT, Par2, n1, n2, n3)
            Matrix sort: Sorts matrix Par1 according to sort vector
            Par2 and places the result back in Par1. Rows of Par1 are
            moved to the corresponding positions indicated by the
            values of Par2. Par2 may be a column of Par1 (in which
            case it will also be reordered). Alternatively, you may
            specify the column of Par1 to sort using n1 (leaving Par2
            blank). A secondary sort can be specified by column n2,
            and a third sort using n3. ParR is the vector of initial
            row positions (the permutation vector).  Sorting Par1
            according to ParR should reproduce the initial ordering.

            NNEAR - (*MOPER, ParR, Par1, NNEAR, Toler)
            Nearest Node: Quickly determine all the nodes within a
            specified tolerance of a given array.  ParR is a vector of
            the nearest selected nodes, or 0 if no nodes are nearer
            than Toler. Par1 is the n x 3 array of coordinate
            locations. Toler defaults to 1 and is limited to the
            maximum model size. - (*MOPER, ParR, Par1, ENEAR, Toler)

            ENEAR - (*MOPER, ParR, Par1, ENEAR, Toler)
            Nearest Element: Quickly determine the elements with
            centroids that are within a specified tolerance of the
            points in a given array. - ParR is a vector of the nearest
            selected elements, or 0 if no element centroids are nearer
            than Toler. Par1 is the n x 3 array of coordinate
            locations.

            MAP - (*MOPER, ParR, Par1, MAP, Par2, Par3, kDim, --, kOut, LIMIT)

            Maps the results from one set of points to another. For
            example, you can map pressures from a CFD analysis onto
            your model for a structural analysis.

            Par1 is the Nout x 3 array of points that will be mapped
            to. Par2 is the Nin x M array that contains M values of
            data to be interpolated at each point and corresponds to
            the Nin x 3 points in Par3. The resulting ParR is the Nout
            x M array of mapped data points.

            For each point in the destination mesh, all possible
            triangles in the source mesh are searched to find the best
            triangle containing each point. It then does a linear
            interpolation inside this triangle. You should carefully
            specify your interpolation method and search criteria in
            order to provide faster and more accurate results (see
            LIMIT, below).

            kDim is the interpolation criteria. If kDim = 2 or 0, two
            dimensional interpolation is applied (interpolate on a
            surface). If kDim = 3, three dimensional interpolation is
            applied (interpolate on a volume).

            kOut specified how points outside of the domain are
            handled. If kOut = 0, use the value(s) of the nearest
            region point for points outside of the region. If kOut =
            1, set results outside of the region to zero.

            LIMIT specifies the number of nearby points considered for
            interpolation. The default is 20, and the minimum is
            5. Lower values will reduce processing time; however, some
            distorted or irregular sets of points will require a
            higher LIMIT value to encounter three nodes for
            triangulation.

            Output points are incorrect if they are not within the
            domain (area or volume) defined by the specified input
            points. Also, calculations for out-of-bound points require
            much more processing time than do points that are within
            bounds. Results mapping is available from the command line
            only.

            INTP - (*MOPER, ParR, Par1, INTP, Par2)
            Finds the elements that contain each point in the array of
            n x 3 points in Par1. Par2 will contain the set of element
            ID numbers and ParR will contain their n x 3 set of
            natural element coordinates (values between -1 and
            1). Par1 must be in global Cartesian coordinates.

            SGET - (*MOPER, ParR, Par1, SGET, Par2, Label, Comp)
            Gets the nodal solution item corresponding to Label and
            Comp (see the PLNSOL command) and interpolates it to the
            given element locations. Par1 contains the n x 3 array of
            natural element coordinates (values between -1 and 1) of
            the n element ID numbers in Par2. Par1 and Par2 are
            usually the output of the *MOPER,,,INTP operation. ParR
            contains the n interpolated results.

            Val1, Val2, ..., Val6
            Additional input used in the operation. The meanings of
            Val1 through Val6 vary depending on the specified matrix
            operation. See the description of Oper for details.
        """
        command = f"*MOPER,{parr},{par1},{oper},{val1},{val2},{val3},{val4},{val5},{val6}"
        return self.run(command, **kwargs)

    def mwrite(self, parr="", fname="", ext="", label="", n1="", n2="", n3="",
               **kwargs):
        """Writes a matrix to a file in a formatted sequence.

        APDL Command: *MWRITE

        Parameters
        ----------
        parr
            The name of the array parameter. See *SET for name restrictions.

        fname
            File name and directory path (248 characters maximum, including the
            characters needed for the directory path).  An unspecified
            directory path defaults to the working directory; in this case, you
            can use all 248 characters for the file name.

        ext
            Filename extension (eight-character maximum).

        label
            Can use a value of IJK, IKJ, JIK, JKI, KIJ, KJI, or blank (JIK).

        n1, n2, n3
            Write as (((ParR(i,j,k), k = 1,n1), i = 1, n2), j = 1, n3) for
            Label = KIJ. n1, n2, and n3 default to the corresponding dimensions
            of the array parameter ParR.

        Notes
        -----
        Writes a matrix or vector to a specified file in a formatted sequence.
        You can also use the *VWRITE command to write data to a specified file.
        Both commands contain format descriptors on the line immediately
        following the command. The format descriptors can be in either Fortran
        or C format.

        Fortran format descriptors are enclosed in parentheses. They must
        immediately follow the *MWRITE command on a separate line of the same
        input file. The word FORMAT should not be included. The format must
        specify the number of fields to be written per line, the field width,
        the placement of the decimal point, etc. There should be one field
        descriptor for each data item written. The write operation uses the
        available system FORTRAN FORMAT conventions (see your system FORTRAN
        manual). Any standard FORTRAN real format (such as (4F6.0),
        (E10.3,2X,D8.2), etc.) and character format (A) may be used.  Integer
        (I) and list-directed (*) descriptors may not be used. Text may be
        included in the format as a quoted string. The FORTRAN descriptor must
        be enclosed in parentheses and the format must not exceed 80 characters
        (including parentheses).

        The "C" format descriptors are used if the first character of the
        format descriptor line is not a left parenthesis. "C" format
        descriptors may be up to 80 characters long, consisting of text strings
        and predefined "data descriptors" between the strings where numeric or
        alphanumeric character data are to be inserted. The normal descriptors
        are %I for integer data, %G for double precision data, %C for
        alphanumeric character data, and %/ for a line break. There must be one
        data descriptor for each specified value in the order of the specified
        values. The enhanced formats described in *MSG may also be used.

        The starting array element number must be defined. Looping continues in
        the directions indicated by the Label argument. The number of loops and
        loop skipping may also be controlled with the *VLEN and *VMASK
        commands, which work in the n2 direction (by row on the output file),
        and by  the *VCOL command, which works in the n1 direction (by column
        in the output file).  The vector specifications *VABS and *VFACT apply
        to this command, while *VCUM does not apply to this command. See the
        *VOPER command for details. If you are in the GUI, the *MWRITE command
        must be contained in an externally prepared file and read into ANSYS
        (i.e., *USE, /INPUT, etc.).

        This command is valid in any processor.
        """
        command = f"*MWRITE,{parr},{fname},{ext},,{label},{n1},{n2},{n3}"
        return self.run(command, **kwargs)

    def starvput(self, parr="", entity="", entnum="", item1="", it1num="",
                 item2="", it2num="", kloop="", **kwargs):
        """Restores array parameter values into the ANSYS database.

        APDL Command: *VPUT

        Parameters
        ----------
        parr
            The name of the input vector array parameter.  See *SET for name
            restrictions.  The parameter must exist as a dimensioned array
            [*DIM] with data input.

        entity
            Entity keyword.  Valid keywords are shown for Entity = in the table
            below.

        entnum
            The number of the entity (as shown for ENTNUM= in the table below).

        item1
            The name of a particular item for the given entity.  Valid items
            are as shown in the Item1 columns of the table below.

        it1num
            The number (or label) for the specified Item1 (if any).  Valid
            IT1NUM values are as shown in the IT1NUM columns of the table
            below.  Some Item1 labels do not require an IT1NUM value.

        item2, it2num
            A second set of item labels and numbers to further qualify the item
            for which data is to be stored.  Most items do not require this
            level of information.

        kloop
            Field to be looped on:

            Loop on the ENTNUM field (default). - Loop on the Item1 field.

            Loop on the IT1NUM field.  Successive items are as shown with IT1NUM. - Loop on the Item2 field.

        Notes
        -----
        The *VPUT command is not supported for PowerGraphics displays.
        Inconsistent results may be obtained if this command is not used in
        /GRAPHICS, FULL.

        Plot and print operations entered via the GUI (Utility Menu> Pltcrtls,
        Utility Menu> Plot) incorporate the AVPRIN command. This means that the
        principal and equivalent values are recalculated. If you use *VPUT to
        put data back into the database, issue the plot commands from the
        command line to preserve your data.

        This operation is basically the inverse of the *VGET operation.  Vector
        items are put directly (without any coordinate system transformation)
        into the ANSYS database.  Items can only replace existing items of the
        database and not create new items.  Degree of freedom results that are
        replaced in the database are available for all subsequent
        postprocessing operations.  Other results are changed temporarily and
        are available mainly for the immediately following print and display
        operations.  The vector specification *VCUM does not apply to this
        command.  The valid labels for the location fields (Entity, ENTNUM,
        Item1, and IT1NUM) are listed below.  Item2 and IT2NUM are not
        currently used.  Not all items from the *VGET list are allowed on *VPUT
        since putting values into some locations could cause the database to be
        inconsistent.

        This command is valid in any processor.

        Table: 250:: : *VPUT - POST1 Items

        X, Y, or Z fluid velocity. X, Y, or Z nodal velocity in a transient
        structural analysis (LS-DYNA analysis or analysis with ANTYPE,TRANS).

        X, Y, or Z magnetic vector potential. X, Y, or Z nodal acceleration in
        a transient structural analysis (LS-DYNA analysis or analysis with
        ANTYPE,TRANS).
        """
        command = f"*VPUT,{parr},{entity},{entnum},{item1},{it1num},{item2},{it2num},{kloop}"
        return self.run(command, **kwargs)

    def sread(self, strarray="", fname="", ext="", nchar="", nskip="",
              nread="", **kwargs):
        """Reads a file into a string array parameter.

        APDL Command: *SREAD

        Parameters
        ----------
        strarray
            Name of the "string array" parameter which will hold the read file.
            String array parameters are similar to character arrays, but each
            array element can be as long as 128 characters. If the string
            parameter does not exist, it will be created. The array will be
            created as: *DIM,StrArray,STRING,nChar,nRead

        fname
            File name and directory path (248 characters maximum, including the
            characters needed for the directory path).  An unspecified
            directory path defaults to the working directory; in this case, you
            can use all 248 characters for the file name.

        ext
            Filename extension (eight-character maximum).

        nchar
            Number of characters per line to read (default is length of the
            longest line in the file).

        nskip
            Number of lines to skip at the start of the file (default is 0).

        nread
            Number of lines to read from the file (default is the entire file).

        Notes
        -----
        The *SREAD command reads from a file into a string array
        parameter. The file must be an ASCII text file.
        """
        command = f"*SREAD,{strarray},{fname},{ext},,{nchar},{nskip},{nread}"
        return self.run(command, **kwargs)

    def toper(self, parr="", par1="", oper="", par2="", fact1="", fact2="",
              con1="", **kwargs):
        """Operates on table parameters.

        APDL Command: *TOPER

        Parameters
        ----------
        parr
            Name of the resulting table parameter. The command will create a
            table array parameter with this name.  Any existing parameter with
            this name will be overwritten.

        par1
            Name of the first table parameter.

        oper
            The operation to be performed: ADD.  The operation is:  ParR(i,j,k)
            =   FACT1*Par1(i,j,k) + FACT2 *Par2(i,j,k) +CON1

        par2
            Name of the second table parameter.

        fact1
            The first table parameter multiplying constant. Defaults to 1.

        fact2
            The second table parameter multiplying constant.  Defaults to 1.

        con1
            The constant increment for offset.  Defaults to 0.

        Notes
        -----
        *TOPER operates on table parameters according to: ParR(i,j,k) =
        FACT1*Par1(i,j,k) + FACT2 *Par2(i,j,k) +CON1

        Par1 and Par2 must have the same dimensions and the same variable names
        corresponding to those dimensions. Par1 and Par2 must also have
        identical index values for rows, columns, etc.

        If you want a local coordinate system for the resulting array, you must
        dimension it as such using the *DIM command before issuing *TOPER.

        This command is valid in any processor.
        """
        command = f"*TOPER,{parr},{par1},{oper},{par2},{fact1},{fact2},{con1}"
        return self.run(command, **kwargs)

    def vabs(self, kabsr="", kabs1="", kabs2="", kabs3="", **kwargs):
        """Applies the absolute value function to array parameters.

        APDL Command: *VABS

        Parameters
        ----------
        kabsr
            Absolute value of results parameter:

            Do not take absolute value of results parameter (ParR). - Take absolute value.

        kabs1
            Absolute value of first parameter:

            Do not take absolute value of first parameter (Par1 or ParI). - Take absolute value.

        kabs2
            Absolute value of second parameter:

            Do not take absolute value of second parameter (Par2 or ParJ). - Take absolute value.

        kabs3
            Absolute value of third parameter:

            Do not take absolute value of third parameter (Par3 or ParK). - Take absolute value.

        Notes
        -----
        Applies an absolute value to parameters used in certain  *VXX and  *MXX
        operations.  Typical absolute value applications are of the form:

        ParR = |f(|Par1|)|

        or

        ParR = |(|Par1| o |Par2|)|

        The absolute values are applied to each input parameter value before
        the operation and to the result value after the operation.  Absolute
        values are applied before the scale factors so that negative scale
        factors may be used.  The absolute value settings are reset to the
        default (no absolute value) after each *VXX or *MXX operation.  Use
        *VSTAT to list settings.

        This command is valid in any processor.
        """
        command = f"*VABS,{kabsr},{kabs1},{kabs2},{kabs3}"
        return self.run(command, **kwargs)

    def vcol(self, ncol1="", ncol2="", **kwargs):
        """Specifies the number of columns in matrix operations.

        APDL Command: *VCOL

        Parameters
        ----------
        ncol1
            Number of columns to be used for Par1 with *MXX operations.
            Defaults to whatever is needed to fill the result array.

        ncol2
            Number of columns to be used for Par2 with *MXX operations.
            Defaults to whatever is needed to fill the result array.

        Notes
        -----
        Specifies the number of columns to be used in array parameter matrix
        operations.  The size of the submatrix used is determined from the
        upper left starting array element (defined on the operation command) to
        the lower right array element (defined by the number of columns on this
        command and the number of rows on the *VLEN command).

        The default NCOL is calculated from the maximum number of columns of
        the result array (the *DIM column dimension) minus the starting
        location + 1.  For example, *DIM,R,,1,10 and a starting location of
        R(1,7) gives a default of 4 columns ( starting with R(1,7), R(1,8),
        R(1,9), and R(1,10)).  Repeat operations automatically terminate at the
        last column of the result array.  Existing values in the rows and
        columns of the results matrix remain unchanged where not overwritten by
        the requested input or operation values.

        The column control settings are reset to the defaults after each *MXX
        operation.  Use *VSTAT to list settings.

        This command is valid in any processor.
        """
        command = f"*VCOL,{ncol1},{ncol2}"
        return self.run(command, **kwargs)

    def vcum(self, key="", **kwargs):
        """Allows array parameter results to add to existing results.

        APDL Command: *VCUM

        Parameters
        ----------
        key
            Accumulation key:

            Overwrite results. - Add results to the current value of the results parameter.

        Notes
        -----
        Allows results from certain *VXX and *MXX operations to overwrite or
        add to existing results.  The cumulative operation is of the form:

        ParR = ParR + ParR(Previous)

        The cumulative setting is reset to the default (overwrite) after each
        *VXX or *MXX operation.  Use *VSTAT to list settings.

        This command is valid in any processor.
        """
        command = f"*VCUM,{key}"
        return self.run(command, **kwargs)

    def vfact(self, factr="", fact1="", fact2="", fact3="", **kwargs):
        """Applies a scale factor to array parameters.

        APDL Command: *VFACT

        Parameters
        ----------
        factr
            Scale factor applied to results (ParR) parameter.  Defaults to 1.0.

        fact1
            Scale factor applied to first parameter (Par1 or ParI).  Defaults
            to 1.0.

        fact2
            Scale factor applied to second parameter (Par2 or ParJ).  Defaults
            to 1.0.

        fact3
            Scale factor applied to third parameter (Par3 or ParK).  Defaults
            to 1.0.

        Notes
        -----
        Applies a scale factor to parameters used in certain *VXX and *MXX
        operations.   Typical scale factor applications are of the form:

        ParR = FACTR*f(FACT1*Par1)

        or

        ParR = FACTR*((FACT1*Par1) o (FACT2*Par2))

        The factors are applied to each input parameter value before the
        operation and to the result value after the operation.  The scale
        factor settings are reset to the default (1.0) after each *VXX or *MXX
        operation.  Use *VSTAT to list settings.

        This command is valid in any processor.
        """
        command = f"*VFACT,{factr},{fact1},{fact2},{fact3}"
        return self.run(command, **kwargs)

    def vfun(self, parr="", func="", par1="", con1="", con2="", con3="",
             **kwargs):
        """Performs a function on a single array parameter.

        APDL Command: *VFUN

        Parameters
        ----------
        parr
            The name of the resulting numeric array parameter vector.  See *SET
            for name restrictions.

        func
            Function to be performed:

            Arccosine: ACOS(Par1). - Arcsine: ASIN(Par1).

            Par1 is sorted in ascending order.  *VCOL, *VMASK, *VCUM, and *VLEN,,NINC do not apply.  *VLEN,NROW does apply. - Arctangent: ATAN(Par1).

            Compress:  Selectively compresses data set.  "True" (*VMASK) values of Par1 (or row positions to be considered according to the NINC value on the *VLEN command) are written in  compressed form to ParR, starting at the specified position. - Copy: Par1 copied to ParR.

            Cosine: COS(Par1). - Hyperbolic cosine: COSH(Par1).

            Direction cosines of the principal stresses (nX9).  Par1 contains the nX6 component stresses for the n locations of the calculations. - Par1 is sorted in descending order.  *VCOL, *VMASK, *VCUM, and *VLEN,,NINC do
                              not apply.  *VLEN,NROW does apply.

            Euler angles of the principal stresses (nX3).  Par1 contains the nX6 component stresses for the n locations of the calculations. - Exponential: EXP(Par1).

            Expand:  Reverse of the COMP function.  All elements of Par1 (starting at the position specified) are written in expanded form to corresponding "true" (*VMASK) positions (or row positions to be considered according to the NINC value on the *VLEN command) of ParR. - Natural logarithm: LOG(Par1).

            Common logarithm: LOG10(Par1). - Nearest integer: 2.783 becomes 3.0, -1.75 becomes -2.0.

            Logical complement: values   0.0 (false) become 1.0 (true).  Values > 0.0 (true) become 0.0 (false). - Principal stresses (nX5). Par1 contains the nX6 component stresses for the n
                              locations of the calculations.

            Power function: Par1**CON1. Exponentiation of any negative number in the vector Par1 to a non-integer power is performed by exponentiating the positive number and prepending the minus sign. For example, -4**2.3 is -(4**2.3). - Sine: SIN(Par1).

            Hyperbolic sine: SINH(Par1). - Square root: SQRT(Par1).

            Tangent: TAN(Par1). - Hyperbolic tangent: TANH(Par1).

            Tangent to a path at a point:  the slope at a point is determined by linear interpolation half way between the previous and next points.  Points are assumed to be in the global Cartesian coordinate system.  Path points are specified in array Par1 (having 3 consecutive columns of data, with the columns containing the x, y, and z coordinate locations, respectively, of the points).  Only the starting row index and the column index for the x coordinates are specified, such as A(1,1).  The y and z coordinates of the vector are assumed to begin in the corresponding next columns, such as A(1,2) and A(1,3).  The tangent result, ParR, must also have 3 consecutive columns of data and will contain the tangent direction vector (normalized to 1.0); such as 1,0,0 for an x-direction vector. - Normal to a path and an input vector at a point: determined from the cross-
                              product of the calculated tangent vector (see
                              TANG) and the input direction vector (with the i,
                              j, and k components input as CON1, CON2, and
                              CON3).  Points are assumed to be in the global
                              Cartesian coordinate system.  Path points are
                              specified in array Par1 (having 3 consecutive
                              columns of data, with the columns containing the
                              x, y, and z coordinate locations, respectively,
                              of the points).  Only the starting row index and
                              the column index for the x coordinates are
                              specified, such as A(1,1).  The y and z
                              coordinates of the vector are assumed to begin in
                              the corresponding next columns, such as A(1,2)
                              and A(1,3).  The normal result, ParR, must also
                              have 3 consecutive columns of data and will
                              contain the normal direction vector (normalized
                              to 1.0); such as 1,0,0 for an x-direction vector.

            Transforms global Cartesian coordinates of a point to the coordinates of a specified system: points to be transformed are specified in array Par1 (having 3 consecutive columns of data, with the columns containing the x, y, and z global Cartesian coordinate locations, respectively, of the points).  Only the starting row index and the column index for the x coordinates are specified, such as A(1,1).  The y and z coordinates of the vector are assumed to begin in the corresponding next columns, such as A(1,2) and A(1,3).  Results are transformed to coordinate system CON1 (which may be any valid coordinate system number, such as 1,2,11,12, etc.).  The transformed result, ParR, must also have 3 consecutive columns of data and will contain the corresponding transformed coordinate locations. - Transforms specified coordinates of a point to global Cartesian coordinates:
                              points to be transformed are specified in array
                              Par1 (having 3 consecutive columns of data, with
                              the columns containing the local coordinate
                              locations (x, y, z or r, θ, z or etc.) of the
                              points).  Only the starting row index and the
                              column index for the x coordinates are specified,
                              such as A(1,1).  The y and z coordinates (or θ
                              and z, or etc.) of the vector are assumed to
                              begin in the corresponding next columns, such as
                              A(1,2) and A(1,3).  Local coordinate locations
                              are assumed to be in coordinate system CON1
                              (which may be any valid coordinate system number,
                              such as 1,2,11,12, etc.).  The transformed
                              result, ParR, must also have 3 consecutive
                              columns of data, with the columns containing the
                              global Cartesian x, y, and z coordinate
                              locations, respectively.

        par1
            Array parameter vector in the operation.

        con1, con2, con3
            Constants (used only with the PWR, NORM, LOCAL, and GLOBAL
            functions).

        Notes
        -----
        Operates on one input array parameter vector and produces one output
        array parameter vector according to:

        ParR = f(Par1)

        where the functions (f) are described below.  Functions are based on
        the standard FORTRAN definitions where possible.  Out-of-range function
        results (or results with exponents whose magnitudes are approximately
        greater than 32 or less than -32) produce a zero value.  Input and
        output for angular functions may be radians (default) or degrees
        [*AFUN].  ParR may be the same as Par1.  Starting array element numbers
        must be defined for each array parameter vector if it does not start at
        the first location. For example, *VFUN,A,SQRT,B(5) takes the square
        root of the fifth element of B and stores the result in the first
        element of A.  Operations continue on successive array elements [*VLEN,
        *VMASK] with the default being all successive elements.  Absolute
        values and scale factors may be applied to all parameters [*VABS,
        *VFACT].  Results may be cumulative [*VCUM].  Skipping array elements
        via *VMASK or *VLEN for the TANG and NORM functions skips only the
        writing of the results (skipped array element data are used in all
        calculations).  See the *VOPER command for detail   s   .   /   p   >
        p   >   T   h   i   s       c   o   m   m   a   n   d       i   s
        v   a   l   i   d       i   n       a   n   y       p   r   o   c   e
        s   s   o   r   .   /   p   >   /   d   i   v   >   d   i   v       c
        l   a   s   s   =   "   r   e   f   s   e   c   t   1   "       t   i
        t   l   e   =   "   M   e   n   u       P   a   t   h   s   "   >   a
        n   a   m   e   =   "   d   0   e   2   9   2   8   5   8   "   >   /
        a   >   h   2   >   M   e   n   u       P   a   t   h   s   /   h   2
        >   t   a   b   l   e       b   o   r   d   e   r   =   "   0   "
        s   u   m   m   a   r   y   =   "   S   i   m   p   l   e       l   i
        s   t   "       c   l   a   s   s   =   "   s   i   m   p   l   e   l
        i   s   t   "   >   t   r   >   t   d   >   s   p   a   n       c   l
        a   s   s   =   "   g   u   i   m   e   n   u   "   >   s   t   r   o
        n   g   >   U   t   i   l   i   t   y       M   e   n   u   &g   t   ;
        P   a   r   a   m   e   t   e   r   s   &g   t   ;   A   r   r   a   y
        O   p   e   r   a   t   i   o   n   s   &g   t   ;   V   e   c   t   o
        r       F   u   n   c   t   i   o   n   s   /   s   t   r   o   n   g
        >   /   s   p   a   n   >   /   t   d   >   /   t   r   >   /   t   a
        b   l   e   >   /   d   i   v   >   /   d   i   v   >   h   r   >   p
        c   l   a   s   s   =   "   l   e   g   a   l   f   o   o   t   e   r
        "   >   s   m   a   l   l   >   i   >   R   e   l   e   a   s   e
        1   6   .   2       -       &c   o   p   y   ;       S   A   S       I
        P   ,       I   n   c   .       A   l   l       r   i   g   h   t   s
        r   e   s   e   r   v   e   d   .   /   i   >   /   s   m   a   l   l
        >   /   p   >   /   b   o   d   y   >   /   h   t   m   l   >
        """
        command = f"*VFUN,{parr},{func},{par1},{con1},{con2},{con3}"
        return self.run(command, **kwargs)

    def vitrp(self, parr="", part="", pari="", parj="", park="", **kwargs):
        """Forms an array parameter by interpolation of a table.

        APDL Command: *VITRP

        Parameters
        ----------
        parr
            The name of the resulting array parameter.  See *SET for name
            restrictions.

        part
            The name of the TABLE array parameter.  The parameter must exist as
            a dimensioned array of type TABLE [*DIM].

        pari
            Array parameter vector of I (row) index values for interpolation in
            ParT.

        parj
            Array parameter vector of J (column) index values for interpolation
            in ParT (which must be at least 2-D).

        park
            Array parameter vector of K (depth) index values for interpolation
            in ParT (which must be 3-D).

        Notes
        -----
        Forms an array parameter (of type ARRAY) by interpolating values of an
        array parameter (of type TABLE) at specified table index locations
        according to:

        ParR = f(ParT, Parl, ParJ, ParK)

        where ParT is the type TABLE array parameter, and ParI, ParJ, ParK are
        the type ARRAY array parameter vectors of index values for
        interpolation in ParT.  See the *DIM command for TABLE and ARRAY
        declaration types.  Linear interpolation is used.  The starting array
        element number for the TABLE array (ParT) is not used (but a value must
        be input).  Starting array element numbers must be defined for each
        array parameter vector if it does not start at the first location. For
        example, *VITRP,R(5),TAB(1,1),X(2),Y(4) uses the second element of X
        and the fourth element of Y as index values (row and column) for a 2-D
        interpolation in TAB and stores the result in the fifth element of R.
        Operations continue on successive array elements [*VLEN, *VMASK] with
        the default being all successive elements.  Absolute values and scale
        factors may be applied to the result parameter [*VABS, *VFACT].
        Results may be cumulative [*VCUM].  See the *VOPER command for details.

        This command is valid in any processor.
        """
        command = f"*VITRP,{parr},{part},{pari},{parj},{park}"
        return self.run(command, **kwargs)

    def vlen(self, nrow="", ninc="", **kwargs):
        """Specifies the number of rows to be used in array parameter operations.

        APDL Command: *VLEN

        Parameters
        ----------
        nrow
            Number of rows to be used with the *VXX or *MXX operations.
            Defaults to the number of rows needed to fill the result array.

        ninc
            Perform the operation on every NINC row (defaults to 1).

        Notes
        -----
        Specifies the number of rows to be used in array parameter operations.
        The size of the submatrix used is determined from the upper left
        starting array element (defined on the operation command) to the lower
        right array element (defined by the number of rows on this command and
        the number of columns on the *VCOL command).  NINC allows skipping row
        operations for some operation commands.  Skipped rows are included in
        the row count.  The starting row number must be defined on the
        operation command for each parameter read and for the result written.

        The default NROW is calculated from the maximum number of rows of the
        result array (the *DIM row dimension) minus the starting location + 1.
        For example, *DIM,R,,10 and a starting location of R(7) gives a default
        of 4 loops (filling R(7), R(8), R(9), and R(10)).  Repeat operations
        automatically terminate at the last row of the result array.  Existing
        values in the rows and columns of the results matrix remain unchanged
        where not overwritten by the requested input or operation values.

        The stride (NINC) allows operations to be performed at regular
        intervals.  It has no effect on the total number of row operations.
        Skipped operations retain the previous result.  For example, *DIM,R,,6,
        with a starting location of R(1), NROW = 10, and NINC = 2 calculates
        values for locations R(1), R(3), and R(5) and retains values for
        locations R(2), R(4), and R(6).  A more general skip control may be
        done by masking [*VMASK].  The row control settings are reset to the
        defaults after each *VXX or *MXX operation.  Use *VSTAT to list
        settings.

        This command is valid in any processor.
        """
        command = f"*VLEN,{nrow},{ninc}"
        return self.run(command, **kwargs)

    def vmask(self, par="", **kwargs):
        """Specifies an array parameter as a masking vector.

        APDL Command: *VMASK

        Parameters
        ----------
        par
            Name of the mask parameter.  The starting subscript must also be
            specified.

        Notes
        -----
        Specifies the name of the parameter whose values are to be checked for
        each resulting row operation.  The mask vector usually contains only 0
        (for false) and 1 (for true) values.  For each row operation the
        corresponding mask vector value is checked.  A true value allows the
        operation to be done.  A false value skips the operation (and retains
        the previous results).  A mask vector can be created from direct input,
        such as M(1) = 1,0,0,1,1,0,1; or from the DATA function of the *VFILL
        command.  The NOT function of the *VFUN command can be used to reverse
        the logical sense of the mask vector.  The logical compare operations
        (LT, LE, EQ, NE, GE, and GT) of the *VOPER command also produce a mask
        vector by operating on two other vectors.  Any numeric vector can be
        used as a mask vector since the actual interpretation assumes values
        less than 0.0 are 0.0 (false) and values greater than 0.0 are 1.0
        (true).  If the mask vector is not specified (or has fewer values than
        the result vector), true (1.0) values are assumed for the unspecified
        values.  Another skip control may be input with NINC on the *VLEN
        command.  If both are present, operations occur only when both are
        true.  The mask setting is reset to the default (no mask) after each
        *VXX or *MXX operation.  Use *VSTAT to list settings.

        This command is valid in any processor.
        """
        command = f"*VMASK,{par}"
        return self.run(command, **kwargs)

    def voper(self, parr="", par1="", oper="", par2="", con1="", con2="",
              **kwargs):
        """Operates on two array parameters.

        APDL Command: *VOPER

        Parameters
        ----------
        parr
            The name of the resulting array parameter vector.  See *SET  for
            name restrictions.

        par1
            First array parameter vector in the operation.  May also be a
            scalar parameter or a literal constant.

        oper
            Operations:

            Addition: Par1+Par2. - Subtraction: Par1-Par2.

            Multiplication: Par1*Par2. - Division: Par1/Par2  (a divide by zero results in a value of zero).

            Minimum: minimum of Par1 and Par2. - Maximum: maximum of Par1 and Par2.

            Less than comparison: Par1<Par2 gives 1.0 if true, 0.0 if false. - Less than or equal comparison: Par1 Par2 gives 1.0 if true, 0.0 if false.

            Equal comparison: Par1 = Par2 gives 1.0 if true, 0.0 if false. - Not equal comparison: Par1 ≠ Par2 gives 1.0 if true, 0.0 if false.

            Greater than or equal comparison: Par1 Par2 gives 1.0 if true, 0.0 if false. - Greater than comparison: Par1>Par2 gives 1.0 if true, 0.0 if false.

            First derivative: d(Par1)/d(Par2).  The derivative at a point is determined  over points half way between the previous and next points (by linear  interpolation). Par1 must be a function (a unique Par1 value for each Par2 value) and Par2 must be in ascending order. - Second derivative: d2(Par1)/d(Par2)2.  See also DER1.

            Single integral:    Par1 d(Par2), where CON1 is the integration constant.  The integral at a point is determined by using the single integration procedure described in the Mechanical APDL Theory Reference. - Double integral:       Par1 d(Par2), where CON1 is the integration constant of
                              the first integral and CON2 is the integration
                              constant of the second integral.  If Par1
                              contains acceleration data, CON1 is the initial
                              velocity and CON2 is the initial displacement.
                              See also INT1.

            Dot product: Par1  . Par2.  Par1 and Par2 must each have three consecutive columns of data, with the columns containing the i, j, and k vector components, respectively.  Only the starting row index and the column index for the i components are specified for Par1 and Par2, such as A(1,1).  The j and k components of the vector are assumed to begin in the corresponding next columns, such as A(1,2) and A(1,3). - Cross product: Par1 x Par2.  Par1, Par2, and ParR must each have 3 components,
                              respectively.  Only the starting row index and
                              the column index for the i components are
                              specified for Par1, Par2, and ParR, such as
                              A(1,1).  The j and k components of the vector are
                              assumed to begin in the corresponding next
                              columns, such as A(1,2) and A(1,3).

            Gather:  For a vector of position numbers, Par2, copy the value of Par1 at each position number to ParR.  Example:  for Par1 = 10,20,30,40 and Par2 = 2,4,1;  ParR = 20,40,10. - Scatter:  Opposite of GATH operation.  For a vector of position numbers, Par2,
                              copy the value of Par1 to that position number in
                              ParR.  Example: for Par1 = 10,20,30,40,50 and
                              Par2 = 2,1,0,5,3; ParR = 20,10,50,0,40.

            Arctangent: arctangent of Par1/Par2 with the sign of each component considered. - Transform the data in Par1 from the global Cartesian coordinate system to the
                              local coordinate system given in CON1. Par1 must
                              be an N x 3 (i.e., vector) or an N x 6 (i.e.,
                              stress or strain tensor) array. If the local
                              coordinate system is a cylindrical, spherical, or
                              toroidal system, then you must provide the global
                              Cartesian coordinates in Par2 as an N x 3 array.
                              Set CON2 = 1 if the data is strain data.

        par2
            Second array parameter vector in the operation.  May also be a
            scalar parameter or a literal constant.

        con1
            First constant (used only with the INT1 and INT2 operations).

        con2
            Second constant (used only with the INT2 operation).

        Notes
        -----
        Operates on two input array parameter vectors and produces one output
        array parameter vector according to:

        ParR = Par1 o Par2

        where the operations (o) are described below.  ParR may be the same as
        Par1 or Par2.  Absolute values and scale factors may be applied to all
        parameters [*VABS, *VFACT].  Results may be cumulative [*VCUM].
        Starting array element numbers must be defined for each array parameter
        vector if it does not start at the first location, such as
        *VOPER,A,B(5),ADD,C(3) which adds the third element of C to the fifth
        element of B and stores the result in the first element of A.
        Operations continue on successive array elements [*VLEN, *VMASK] with
        the default being all successive elements.  Skipping array elements via
        *VMASK or *VLEN for the DER_ and INT_ functions skips only the writing
        of the results (skipped array element data are used in all
        calculations).

        Parameter functions and operations are available to operate on a scalar
        parameter or a single element of an array parameter, such as SQRT(B) or
        SQRT(A(4)).  See the *SET command for details.  Operations on a
        sequence of array elements can be done by repeating the desired
        function or operation in a do-loop [*DO].  The vector operations within
        the ANSYS program (*VXX commands) are internally programmed do-loops
        that conveniently perform the indicated operation over a sequence of
        array elements.  If the array is multidimensional, only the first
        subscript is incremented in the do-loop, that is, the operation repeats
        in column vector fashion "down" the array.  For example, for A(1,5),
        A(2,5), A(3,5), etc.  The starting location of the row index must be
        defined for each parameter read and for the result written.

        The default number of loops is from the starting result location to the
        last result location and can be altered with the *VLEN command.  A
        logical mask vector may be defined to control at which locations the
        operations are to be skipped [*VMASK].  The default is to skip no
        locations.  Repeat operations automatically terminate at the last array
        element of the result array column if the number of loops is undefined
        or if it exceeds the last result array element.  Zeroes are used in
        operations for values read beyond the last array element of an input
        array column.  Existing values in the rows and columns of the results
        matrix
        """
        command = f"*VOPER,{parr},{par1},{oper},{par2},{con1},{con2}"
        return self.run(command, **kwargs)

    def vscfun(self, parr="", func="", par1="", **kwargs):
        """Determines properties of an array parameter.

        APDL Command: *VSCFUN

        Parameters
        ----------
        parr
            The name of the resulting scalar parameter.  See *SET for name
            restrictions.

        func
            Functions:

            Maximum: the maximum Par1 array element value. - Minimum: the minimum Par1 array element value.

            Index location of the maximum Par1 array element value.  Array Par1 is searched starting from its specified index. - Index location of the minimum Par1 array element value.  Array Par1 is searched
                              starting from its specified index.

            Index location of the first nonzero value in array Par1.  Array Par1 is searched starting from its specified index. - Index location of the last nonzero value in array Par1.  Array Par1 is searched
                              starting from its specified index.

            Sum:  Par1 (the summation of the Par1 array element values). - Median: value of Par1 at which there are an equal number of values above and
                              below.

            Mean: (σ Par1)/NUM, where NUM is the number of summed values. - Variance: (σ ((Par1-MEAN)**2))/NUM.

            Standard deviation: square root of VARI. - Root-mean-square: square root of (σ (Par1**2))/NUM.

        par1
            Array parameter vector in the operation.

        Notes
        -----
        Operates on one input array parameter vector and produces one output
        scalar parameter according to:

        ParR = f(Par1)

        where the functions (f) are described below. The starting array element
        number must be defined for the array parameter vector.  For example,
        *VSCFUN,MU,MEAN,A(1) finds the mean of the A vector values, starting
        from the first value and stores the result as parameter MU.  Operations
        use successive array elements [*VLEN, *VMASK] with the default being
        all successive array elements.  Absolute values and scale factors may
        be applied to all parameters [*VABS, *VFACT].  Results may be
        cumulative [*VCUM].  See the *VOPER command for details.

        This command is valid in any processor.
        """
        command = f"*VSCFUN,{parr},{func},{par1}"
        return self.run(command, **kwargs)

    def vstat(self, **kwargs):
        """Lists the current specifications for the array parameters.

        APDL Command: *VSTAT

        Notes
        -----
        Lists the current specifications for the *VABS, *VCOL, *VCUM, *VFACT,
        *VLEN, and *VMASK commands.

        This command is valid in any processor.
        """
        command = f"*VSTAT,"
        return self.run(command, **kwargs)

    def vwrite(self, par1="", par2="", par3="", par4="", par5="", par6="",
               par7="", par8="", par9="", par10="", par11="", par12="",
               par13="", par14="", par15="", par16="", par17="", par18="",
               par19="", **kwargs):
        """Writes data to a file in a formatted sequence.

        APDL Command: *VWRITE

        Parameters
        ----------
        par1, par2, par3, . . . , par19
            You can write up to 19 parameters (or constants) at a time. Any Par
            values after a blank  Par value are ignored.  If you leave them all
            blank, one line will be written (to write a title or a blank line).
            If you input the keyword SEQU, a sequence of numbers (starting from
            1) will be written for that item.

        Notes
        -----
        You use *VWRITE to write data to a file in a formatted sequence. Data
        items (Par1, Par2, etc.) may be array parameters, scalar parameters,
        character parameters (scalar or array), or constants.  You must
        evaluate expressions and functions in the data item fields before using
        the *VWRITE command, since initially they will be evaluated to a
        constant and remain constant throughout the operation.  Unless a file
        is defined with the *CFOPEN  command, data is written to the standard
        output file. Data written to the standard output file may be diverted
        to a different file by first switching the current output file with the
        /OUTPUT command. You can also use the *MWRITE command to write data to
        a specified file. Both commands contain format descriptors on the line
        immediately following the command. The format descriptors can be in
        either Fortran or C format.

        You must enclose Fortran format descriptors in parentheses. They must
        immediately follow the *VWRITE command on a separate line of the same
        input file.  Do not include the word FORMAT. The format must specify
        the number of fields to be written per line, the field width, the
        placement of the decimal point, etc.  You should use one field
        descriptor for each data item written.  The write operation uses your
        system's available FORTRAN FORMAT conventions (see your system FORTRAN
        manual).  You can use any standard FORTRAN real format (such as
        (4F6.0), (E10.3,2X,D8.2), etc.) and alphanumeric format (A).
        Alphanumeric strings are limited to a maximum of 8 characters for any
        field (A8) using the Fortran format. Use the "C" format for string
        arrays larger than 8 characters. Integer (I) and list-directed (*)
        descriptors may not be used.  You can include text in the format as a
        quoted string.  The parentheses must be included in the format and the
        format must not exceed 80 characters (including parentheses).  The
        output line length is limited to 128 characters.

        The "C" format descriptors are used if the first character of the
        format descriptor line is not a left parenthesis. "C" format
        descriptors are up to 80 characters long, consisting of text strings
        and predefined "data descriptors" between the strings where numeric or
        alphanumeric character data will be inserted.  The normal descriptors
        are %I for integer data, %G for double precision data, %C for
        alphanumeric character data, and %/ for a line break. There must be one
        data descriptor for each specified value (8 maximum) in the order of
        the specified values. The enhanced formats described in *MSG may also
        be used.

        For array parameter items, you must define the starting array element
        number. Looping continues (incrementing the vector index number of each
        array parameter by one) each time you output a line, until the maximum
        array vector element is written.  For example, *VWRITE,A(1) followed by
        (F6.0) will write one value per output line, i.e., A(1), A(2), A(3),
        A(4), etc.  You write constants and scalar parameters with the same
        values for each loop.  You can also control the number of loops and
        loop skipping with the *VLEN and *VMASK commands.  The vector
        specifications *VABS,  *VFACT, and *VCUM  do not apply to this command.
        If looping continues beyond the supplied data array's length, zeros
        will be output for numeric array parameters and blanks for character
        array parameters.  For multi-dimensioned array parameters, only the
        first (row) subscript is incremented.  See the *VOPER command for
        details.  If you are in the GUI, the *VWRITE command must be contained
        in an externally prepared file and read into ANSYS (i.e., *USE, /INPUT,
        etc.).

        This command is valid in any processor.

        Warnings
        --------
        This command cannot be run interactively.  See
        :func:`ansys.mapdl.core.Mapdl.non_interactive`.

        """
        # cannot be in interactive mode
        if not self._store_commands:
            raise RuntimeError('VWRTIE cannot run interactively.  \n\nPlease use '
                               '``with mapdl.non_interactive:``')

        command = f"*VWRITE,{par1},{par2},{par3},{par4},{par5},{par6},{par7},{par8},{par9},{par10},{par11},{par12},{par13},{par14},{par15},{par16},{par17},{par18},{par19}"
        return self.run(command, **kwargs)
