avtContract_p
avtTimeIteratorExpression::ConstructContractWithVarnames(void)
{
    avtDataRequest_p old_dr = executionContract->GetDataRequest();
    std::string varname = GetInternalVarname(0);
    avtDataRequest_p new_dr = new avtDataRequest(old_dr, varname.c_str());
    new_dr->RemoveAllSecondaryVariables();
    for (int i = 1 ; i < NumberOfVariables() ; i++)
    {
        std::string varname = GetInternalVarname(i);
        new_dr->AddSecondaryVariable(varname.c_str());
    }

    avtContract_p rv = new avtContract(executionContract, new_dr);
    return rv;
}
void
avtTimeIteratorExpression::UpdateExpressions(int ts)
{
    ParsingExprList *pel = ParsingExprList::Instance();
    ExpressionList new_list = *(pel->GetList());

    int nvars = varnames.size();
    if (cmfeType == POS_CMFE)
        nvars--;
    for (int i = 0 ; i < nvars ; i++)
    {
        // No new expression has to be made in this case.
        if (VariableComesFromCurrentTime(i))
            continue;

        std::string meshname = 
                           GetInput()->GetInfo().GetAttributes().GetMeshname();
        char expr_defn[1024];
        if (cmfeType == CONN_CMFE)
        {
            SNPRINTF(expr_defn, 1024, "conn_cmfe(<[%d]i:%s>, <%s>)", ts,
                                        varnames[i].c_str(), meshname.c_str());
        }
        else
        {
            int defVarIndex = varnames.size()-1;
            SNPRINTF(expr_defn, 1024, "pos_cmfe(<[%d]i:%s>, <%s>, %s)", ts,
                                        varnames[i].c_str(), meshname.c_str(),
                                        varnames[defVarIndex].c_str());
        }

        std::string exp_name = GetInternalVarname(i);
        
        bool alreadyInList = false;
        for (int j = 0 ; j < new_list.GetNumExpressions() ; j++)
        {
            if (new_list[j].GetName() == exp_name)
            {
                alreadyInList = true;
                new_list[j].SetDefinition(expr_defn);
            }
        }
        if (!alreadyInList)
        {
            Expression exp;
            exp.SetName(exp_name);
            exp.SetDefinition(expr_defn);
            exp.SetType(Expression::Unknown);
            new_list.AddExpressions(exp);
        }
    }

    *(pel->GetList()) = new_list;
}
void
avtTimeIteratorDataTreeIteratorExpression::PrepareAndExecuteDataset(
                                                        vtkDataSet *ds, int ts)
{
    std::vector<vtkDataArray *> ds_vars;
    std::vector<vtkDataArray *> delete_vars;

    bool haveZonal = false;

    size_t nvars = varnames.size();
    if (cmfeType == POS_CMFE)
        nvars--;
    for (size_t i = 0 ; i < nvars ; i++)
    {
        std::string vname = GetInternalVarname(i);
        vtkDataArray *cell_data1 = ds->GetCellData()->GetArray(vname.c_str());
        vtkDataArray *point_data1 = ds->GetPointData()->GetArray(vname.c_str());
        if (cell_data1 == NULL && point_data1 == NULL)
        {
            EXCEPTION2(ExpressionException, outputVariableName,
                       "An internal error occurred when calculating an expression."
                       "  Please contact a VisIt developer.");
        }
        haveZonal = (cell_data1 != NULL);
    }

    bool doZonal = false;
    if (haveZonal)
        doZonal = true;  // mixed centering -> zonal

    for (size_t i = 0 ; i < nvars ; i++)
    {
        std::string vname = GetInternalVarname(i);
        vtkDataArray *cell_data1 = ds->GetCellData()->GetArray(vname.c_str());
        vtkDataArray *point_data1 = ds->GetPointData()->GetArray(vname.c_str());

        if (doZonal)
        { 
            if (cell_data1 != NULL)
                ds_vars.push_back(cell_data1);
            else
            {
                vtkDataArray *tmp = Recenter(ds, point_data1, AVT_NODECENT, 
                                             varnames[i], AVT_ZONECENT);
                ds_vars.push_back(tmp);
                delete_vars.push_back(tmp);
            }
        }
        else
        {
            if (point_data1 != NULL)
                ds_vars.push_back(point_data1);
            else
            {
                vtkDataArray *tmp = Recenter(ds, cell_data1, AVT_ZONECENT, 
                                             varnames[i], AVT_NODECENT);
                ds_vars.push_back(tmp);
                delete_vars.push_back(tmp);
            }
        }
    }

    vtkDataArray *out_arr = vars[arrayIndex++];
    ExecuteDataset(ds_vars, out_arr, ts);

    for (size_t i = 0 ; i < delete_vars.size() ; i++)
        delete_vars[i]->Delete();
}