C++ Expression::SetDefinition方法代码示例

void avtSTARFileFormat::
addDerivedVariables(avtDatabaseMetaData *md, int timeState)
{
    TRACE(md, timestate);
    NOTNULL(mDataManager);

    // if all 11 primary variables there, add the derived variables too
    if(mDataManager->numVariables()==11) {
        Expression e;
        string submenu = "=Derived Variables /";

        int numEntries = sizeof DerivedVariableTable/
                         sizeof DerivedVariableTable[0];

        for(int i=0; i<numEntries; i++) {
            e.SetName(submenu + DerivedVariableTable[i].name);
            e.SetDefinition(DerivedVariableTable[i].expression);
            e.SetType(DerivedVariableTable[i].expressionType);

            DEBUG("adding derived variable '%s'='%s'",
                    DerivedVariableTable[i].name.c_str(),
                    DerivedVariableTable[i].expression.c_str());

            md->AddExpression(&e);
        }
    }
}

void
avtRAWFileFormat::PopulateDatabaseMetaData(avtDatabaseMetaData *md)
{
    avtMeshMetaData *mmd = new avtMeshMetaData;
    mmd->name = "mesh";
    mmd->meshType = AVT_SURFACE_MESH;
    mmd->spatialDimension = 3;
    mmd->topologicalDimension = 2;
    mmd->numBlocks = meshes.size();
    stringVector names;
    for(int i = 0; i < meshes.size(); ++i)
        names.push_back(meshes[i].domainName);
    mmd->blockNames = names;
    md->Add(mmd);

    const char *expdefs[] = {"coord(mesh)[0]","coord(mesh)[1]","coord(mesh)[2]"};
    const char *expnames[] = {"x", "y", "z"};
    for(int i = 0; i < 3; ++i)
    {
        Expression expr;
        expr.SetName(expnames[i]);
        expr.SetDefinition(expdefs[i]);
        expr.SetType(Expression::ScalarMeshVar);
        md->AddExpression(&expr);
    }
}

void
VisItDataServerPrivate::DefineVectorExpression(const std::string &name, const std::string &def)
{
    Expression expr;
    expr.SetName(name);
    expr.SetDefinition(def);
    expr.SetType(Expression::VectorMeshVar);
    exprList.AddExpressions(expr);
}

void
avtOVERFLOWFileFormat::PopulateDatabaseMetaData(avtDatabaseMetaData *md)
{
    //
    // We are using ndomains as a flag to indicate if we have read
    // the file.
    //
    if (!ndomains)
    {
        InitializeFile();
    }

    //
    // Create the mesh metadata
    //
    avtMeshMetaData *mesh = new avtMeshMetaData;
    mesh->name = "mesh";
    mesh->meshType = AVT_CURVILINEAR_MESH;
    mesh->numBlocks = ndomains;
    mesh->blockOrigin = 1;
    mesh->cellOrigin = 1;
    mesh->spatialDimension = 3;
    mesh->topologicalDimension = 3;
    mesh->blockTitle = "Zones";
    mesh->blockPieceName = "Zone";
    mesh->hasSpatialExtents = false;
    md->Add(mesh);

    //
    // Add our variable names
    //
    for (int i=0; i<nq; i++)
    {
        char name[1024];
        SNPRINTF(name, 1024, "Q%d", i+1);
        AddScalarVarToMetaData(md, name, "mesh", AVT_NODECENT);
    }

    //
    // The "global" variables work well as expressions with no type
    //
    for (std::map<string,float>::iterator it=varmap.begin(); it!=varmap.end(); it++)
    {
        Expression exp;
        exp.SetName(it->first);
        char def[1024];
        sprintf(def, "%f", it->second);
        exp.SetDefinition(def);
        exp.SetType(Expression::Unknown);
        md->AddExpression(&exp);
    }

    //
    // And don't forget we got TIME for this file!
    //
    md->SetTime(timestep, varmap["TIME"]);
}

// ****************************************************************************
// Method:  ModelFitCommonPluginInfo::GetCreatedExpressions
//
// Purpose:
//   Get the expressions this operator can generate.
//
// Arguments:
//   md         the metadata to create our expressions around
//
// Programmer:  Rob Sisneros
// Creation:    omitted
//
//  Modifications:
//   Jeremy Meredith, Thu Jan 12 13:28:49 EST 2012
//   Some files, like curves, don't have expressions.  Don't assume
//   we have any meshes in our file.
//   
// ****************************************************************************
ExpressionList *
ModelFitCommonPluginInfo::GetCreatedExpressions(const avtDatabaseMetaData *md)
{
    int i;
    int numMeshes = md->GetNumMeshes();
    if (numMeshes == 0)
        return NULL;

    Expression *e = new Expression();

    char mesh[1024];
    strcpy(mesh, md->GetMesh(0)->name.c_str());

    std::string varname = "operators/ModelFit/model"; //(";
    //varname += mesh;
    //varname += ")";
    e->SetName(varname);
    char defn[1024];
    sprintf(defn, "point_constant(%s, 0)", mesh);
    e->SetDefinition(defn);
    e->SetMeshName(std::string(mesh));
    e->SetType(Expression::ScalarMeshVar);
    e->SetFromOperator(true);
    e->SetOperatorName("ModelFit");
    ExpressionList *expressions = new ExpressionList;
    expressions->AddExpressions(*e);
    delete e;

    e = new Expression();

    varname = "operators/ModelFit/distance"; //(";
    //varname += mesh;
    //varname += ")";
    e->SetName(varname);
    sprintf(defn, "point_constant(%s, 0)", mesh);
    e->SetDefinition(defn);
    e->SetMeshName(std::string(mesh));
    e->SetType(Expression::ScalarMeshVar);
    e->SetFromOperator(true);
    e->SetOperatorName("ModelFit");
    expressions->AddExpressions(*e);

    return expressions;
}

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
avtConnectedComponentsFilter::GetCustomExpressions(std::vector<Expression> &elist)
{
    Expression exp;
    char fullname[1024];
    SNPRINTF(fullname, 1024, "operators/ConnectedComponents/%s", varname.c_str());
    exp.SetName(fullname);
    char defn[1024];
    std::string gzopt = "\"true\"";
    if (!atts.GetEnableGhostNeighborsOptimization())
        gzopt  = "\"false\"";
    SNPRINTF(defn, 1024, "conn_components(%s,%s)", varname.c_str(),gzopt.c_str());
    exp.SetDefinition(defn);
    exp.SetType(Expression::ScalarMeshVar);
    elist.push_back(exp);
}

ExpressionList *
ExtractPointFunction2DCommonPluginInfo::GetCreatedExpressions(const avtDatabaseMetaData *md)
{
    char name[1024];
    char defn[1024];
    ExpressionList *el = new ExpressionList;

    for (int i = 0 ; i < md->GetNumArrays() ; i++)
    {
        const char *array = md->GetArrays(i).name.c_str();
        const char *mesh = md->GetArrays(i).meshName.c_str();

        Expression e;
        sprintf(name, "operators/ExtractPointFunction2D/%s", array);
        e.SetName(name);
        e.SetType(Expression::ScalarMeshVar);
        e.SetFromOperator(true);
        e.SetOperatorName("ExtractPointFunction2D");
        sprintf(defn, "cell_constant(<%s>, 0)", mesh);
        e.SetDefinition(defn);
        el->AddExpressions(e);
    }

    const ExpressionList &oldEL = md->GetExprList();
    for (int i = 0 ; i < oldEL.GetNumExpressions() ; i++)
    {
        const Expression &e = oldEL.GetExpressions(i);
        if (e.GetType() == Expression::ArrayMeshVar)
        {
            {
                if (e.GetFromOperator())
                    continue; // weird ordering behavior otherwise
                Expression e2;
                sprintf(name, "operators/ExtractPointFunction2D/%s", e.GetName().c_str());
                e2.SetName(name);
                e2.SetType(Expression::ScalarMeshVar);
                e2.SetFromOperator(true);
                e2.SetOperatorName("ExtractPointFunction2D");
                sprintf(defn, "cell_constant(<%s>, 0.)", e.GetName().c_str());
                e2.SetDefinition(defn);
                el->AddExpressions(e2);
            }
        }
    }

    return el;
}

void 
avtFluxFilter::GetCustomExpressions(std::vector<Expression> &elist)
{
    Expression exp;
    char fullname[1024];
    SNPRINTF(fullname, 1024, "operators/Flux/%s", varname.c_str());
    exp.SetName(fullname);
    char defn[1024];
    if (atts.GetWeight())
        SNPRINTF(defn, 1024, "dot(cell_surface_normal(%s), %s)*%s", 
                 varname.c_str(), atts.GetFlowField().c_str(), atts.GetWeightField().c_str());
    else
        SNPRINTF(defn, 1024, "dot(cell_surface_normal(%s), %s)", 
                 varname.c_str(), atts.GetFlowField().c_str());
    exp.SetDefinition(defn);
    exp.SetType(Expression::ScalarMeshVar);
    elist.push_back(exp);
}

void
AddExpression(ExpressionList &new_list, std::string &var, int time)
{
    char exp_name[1024];
    SNPRINTF(exp_name, 1024, "AVT_TRACE_HIST_%s", var.c_str());
    char exp_defn[1024];
    const char *meshname = var.c_str(); // The expression language will let
                                        // you put in a variable for the
                                        // meshname since it can use that to 
                                        // find the meshname.
    meshname = "quadmesh";
    SNPRINTF(exp_defn, 1024, "pos_cmfe(<[%d]i:%s>, %s, 0.)", time, 
                                                var.c_str(), meshname);

    Expression exp;
    exp.SetName(exp_name);
    exp.SetDefinition(exp_defn);
    exp.SetType(Expression::Unknown);
    new_list.AddExpressions(exp);
}

avtContract_p
avtVolumeFilter::ModifyContract(avtContract_p contract)
{
    avtContract_p newcontract = NULL;

    if (primaryVariable != NULL)
    {
        delete [] primaryVariable;
    }

    avtDataRequest_p ds = new avtDataRequest(contract->GetDataRequest());
    const char *var = ds->GetVariable();

    bool setupExpr = false;
    char exprDef[128];
    std::string exprName = (std::string)"_expr_" + (std::string)var;

    if (atts.GetScaling() == VolumeAttributes::Linear)
    {
#ifdef HAVE_LIBSLIVR
        if ((atts.GetRendererType() == VolumeAttributes::RayCastingSLIVR) ||
            ((atts.GetRendererType() == VolumeAttributes::RayCasting) && (atts.GetSampling() == VolumeAttributes::Trilinear)))
            ds->SetDesiredGhostDataType(GHOST_ZONE_DATA);
#endif
        newcontract = new avtContract(contract, ds);
        primaryVariable = new char[strlen(var)+1];
        strcpy(primaryVariable, var);
    }
    else if (atts.GetScaling() == VolumeAttributes::Log)
    {
        setupExpr = true;
        if (atts.GetUseColorVarMin())
        {
            char m[16];
            SNPRINTF(m, 16, "%f", atts.GetColorVarMin());
            SNPRINTF(exprDef, 128, "log10withmin(<%s>, %s)", var, m);
        }
        else
        {
            SNPRINTF(exprDef, 128, "log10(<%s>)", var);
        }
        avtDataRequest_p nds = new avtDataRequest(exprName.c_str(),
                               ds->GetTimestep(), ds->GetRestriction());
        nds->AddSecondaryVariable(var);
#ifdef HAVE_LIBSLIVR
        if ((atts.GetRendererType() == VolumeAttributes::RayCastingSLIVR) ||
            ((atts.GetRendererType() == VolumeAttributes::RayCasting) && (atts.GetSampling() == VolumeAttributes::Trilinear)))
            nds->SetDesiredGhostDataType(GHOST_ZONE_DATA);
#endif
        newcontract = new avtContract(contract, nds);
        primaryVariable = new char[exprName.size()+1];
        strcpy(primaryVariable, exprName.c_str());
    }
    else // VolumeAttributes::Skew)
    {
        setupExpr = true;
        SNPRINTF(exprDef, 128, "var_skew(<%s>, %f)", var,
                 atts.GetSkewFactor());
        avtDataRequest_p nds =
            new avtDataRequest(exprName.c_str(),
                               ds->GetTimestep(), ds->GetRestriction());
        nds->AddSecondaryVariable(var);
#ifdef HAVE_LIBSLIVR
        if ((atts.GetRendererType() == VolumeAttributes::RayCastingSLIVR) ||
            ((atts.GetRendererType() == VolumeAttributes::RayCasting) && (atts.GetSampling() == VolumeAttributes::Trilinear)))
            nds->SetDesiredGhostDataType(GHOST_ZONE_DATA);
#endif
        newcontract = new avtContract(contract, nds);
        primaryVariable = new char[strlen(exprName.c_str())+1];
        strcpy(primaryVariable, exprName.c_str());
    }

    if (setupExpr)
    {
        ExpressionList *elist = ParsingExprList::Instance()->GetList();
        Expression *e = NULL;
        for (int i = 0 ; i < elist->GetNumExpressions() ; i++)
        {
            if (elist->GetExpressions(i).GetName() == exprName)
            {
                e = &(elist->GetExpressions(i));
                break;
            }
        }
        bool shouldDelete = false;
        if (e == NULL)
        {
            e = new Expression();
            shouldDelete = true;
        }

        e->SetName(exprName.c_str());
        e->SetDefinition(exprDef);
        e->SetType(Expression::ScalarMeshVar);
        elist->AddExpressions(*e);
        if (shouldDelete)
            delete e;
    }

    newcontract->NoStreaming();
//.........这里部分代码省略.........

avtContract_p
avtVectorFilter::ModifyContract(avtContract_p contract)
{
    avtContract_p rv = contract;
    avtDataRequest_p ds = contract->GetDataRequest();

    //
    // Create the expression definition
    //
    string edef = string("magnitude(<") + ds->GetVariable() + string(">)");


    ExpressionList *elist = ParsingExprList::Instance()->GetList();
    Expression *e = new Expression();
        
    e->SetName(magVarName.c_str());
    e->SetDefinition(edef.c_str());
    e->SetType(Expression::ScalarMeshVar);
    elist->AddExpressions(*e);
    delete e;

    // Create a new dcontract so that we can add the secondary var.
    avtDataRequest_p nds = new avtDataRequest(ds->GetVariable(),
                ds->GetTimestep(), ds->GetRestriction());
    nds->AddSecondaryVariable(magVarName.c_str());
    rv = new avtContract(contract, nds);
    rv->SetCalculateVariableExtents(magVarName, true);
    
    // If we're not using the stride, then we have to calculate
    // the per-domain vectorc count by dividing by the number of
    // domains, which we can't calculate if we're streaming.
    if (!useStride)
        rv->NoStreaming();

    avtDataAttributes &data = GetInput()->GetInfo().GetAttributes();
    if (contract->GetDataRequest()->MayRequireZones() || 
        contract->GetDataRequest()->MayRequireNodes() ||
        origOnly)
    {
        keepNodeZone = true;
        if (data.ValidActiveVariable())
        {
            if (data.GetCentering() == AVT_NODECENT)
            {
                rv->GetDataRequest()->TurnNodeNumbersOn();
            }
            else if (data.GetCentering() == AVT_ZONECENT)
            {
                rv->GetDataRequest()->TurnZoneNumbersOn();
            }
        }
        else 
        {
            // canot determine variable centering, so turn on both
            // node numbers and zone numbers.
            rv->GetDataRequest()->TurnNodeNumbersOn();
            rv->GetDataRequest()->TurnZoneNumbersOn();
        }
    }
    else
    {
        keepNodeZone = false;
    }

    return rv;
}

avtContract_p
avtCracksClipperFilter::ModifyContract(avtContract_p inContract)
{
    calculateDensity = false;

    if (strncmp(pipelineVariable, "operators/CracksClipper",
                strlen("operators/CracksClipper")) == 0)
    {
        calculateDensity = true;
        varname = pipelineVariable;
    }

    // Retrieve secondary variables, if any, to pass along to the 
    // newly created DataSpec
    avtDataRequest_p inDR = inContract->GetDataRequest();
    avtDataRequest_p outDR; 
    avtDataAttributes &inAtts = GetInput()->GetInfo().GetAttributes();
    if (calculateDensity)
    {
        outDR = new avtDataRequest(inDR, inAtts.GetMeshname().c_str());   
    }
    else
    {
        outDR = new avtDataRequest(inDR);
    }


    std::vector<CharStrRef> vars2 = inDR->GetSecondaryVariablesWithoutDuplicates();

    // Add any previously existing SecondaryVariables.
    for (size_t i = 0; i < vars2.size(); i++)
    {
        outDR->AddSecondaryVariable(*(vars2[i]));
    }
    // Add secondary variables necessary for CracksClipper
    outDR->AddSecondaryVariable(atts.GetCrack1Var().c_str());
    outDR->AddSecondaryVariable(atts.GetCrack2Var().c_str());
    outDR->AddSecondaryVariable(atts.GetCrack3Var().c_str());
    outDR->AddSecondaryVariable(atts.GetStrainVar().c_str());

    if (calculateDensity)
    {
        outDR->AddSecondaryVariable(atts.GetInMassVar().c_str());
    }


    ExpressionList *elist = ParsingExprList::Instance()->GetList();
    Expression *e = new Expression();

    std::string edef = std::string("volume2(<") + inAtts.GetMeshname() + 
                       std::string(">)");
    e->SetName("cracks_vol");
    e->SetDefinition(edef.c_str());
    e->SetType(Expression::ScalarMeshVar);
    elist->AddExpressions(*e);
    delete e;

    outDR->AddSecondaryVariable("cracks_vol");


    avtContract_p rv = new avtContract(inContract, outDR);

    //
    // Since this filter 'clips' the dataset, the zone and possibly
    // node numbers will be invalid, request them when needed.
    //
    if (inContract->GetDataRequest()->MayRequireZones() || 
        inContract->GetDataRequest()->MayRequireNodes())
    {
        if (inAtts.ValidActiveVariable())
        {
            if (inAtts.GetCentering() == AVT_NODECENT)
            {
                rv->GetDataRequest()->TurnNodeNumbersOn();
            }
            else if (inAtts.GetCentering() == AVT_ZONECENT)
            {
                rv->GetDataRequest()->TurnZoneNumbersOn();
            }
        }
        else 
        {
            // canot determine variable centering, so turn on both
            // node numbers and zone numbers.
            rv->GetDataRequest()->TurnNodeNumbersOn();
            rv->GetDataRequest()->TurnZoneNumbersOn();
        }
    }
    return rv; 
}

void avtSTARFileFormat::
PopulateDatabaseMetaData(avtDatabaseMetaData *md, int timeState)
{
    TRACE(md,timeState);
    NOTNULL(mDataManager);
    BOUNDS_CHECK(mResolution, 0, mDataManager->numResolutions());
    DEBUG("md=%p, timeState=%d", md, timeState);

    const double* extents = NULL;       // not sure why this is NULL
    int numBlocks = mDataManager->numXchunks(mResolution) *
                    mDataManager->numYchunks(mResolution) *
                    mDataManager->numZchunks(mResolution);

    int blockOrigin = 0;                // must be 0 for Single Domain?
    int numDims = 3;
    int topologyDimension = 3;
    const char* meshname = "ggcm";

    AddMeshToMetaData(md,
                      meshname,
                      AVT_RECTILINEAR_MESH,
                      extents,
                      numBlocks,
                      blockOrigin,
                      numDims,
                      topologyDimension);

    // assuming there is only one mesh...
    avtMeshMetaData& mmd = md->GetMeshes(0);
    mmd.LODs = mDataManager->numResolutions() - 1;
    debug4 << "Telling VisIt we have " << mmd.LODs << " levels of detail.\n";

    for(int i=0; i<mDataManager->numVariables(); i++) {
        string varname = mDataManager->variableNameAt(i);

        if(mDataManager->isVectorComponent(varname)) {
            DEBUG("Adding vector component '%s'", varname.c_str());

            // following set of commands equivalent to AddScalarVarToMetaData()
            avtScalarMetaData *smd = new avtScalarMetaData();
            smd->name = varname.c_str();
            smd->meshName = meshname;
            smd->centering = AVT_NODECENT;
            // end equivalent to calling AddScalarVarToMetaData()
            
            smd->hideFromGUI = true; // dont put vector components on menu
            md->Add(smd);
        }
        else if(mDataManager->isScalar(varname)) {
            DEBUG("Adding scalar '%s'", varname.c_str());
            AddScalarVarToMetaData(md, varname.c_str(), meshname, AVT_NODECENT);

            if(mDataManager->hasMinVal() && mDataManager->hasMaxVal()) {
                double minmax[2];
                minmax[0] = mDataManager->minVal();
                minmax[1] = mDataManager->maxVal();
                md->SetExtents(varname.c_str(), minmax);
            }
        }
        else if(mDataManager->isVector(varname)) {
            DEBUG("Adding vector '%s'", varname.c_str());
            AddVectorVarToMetaData(md, varname.c_str(), meshname, AVT_NODECENT, 
                               numDims);
        }
        else if(mDataManager->isTensor(varname)) {
            ERROR("Tensors not supported yet");
        }
    }

    for(int i=0; i<mDataManager->numVectorExpressions(); i++) {
        string expression = mDataManager->vectorExpressionAt(i);

        vector<string> components = split(expression, " \t\n,{};");
        string name = components[0].erase(components[0].length()-1);

        Expression vectorvar;
        vectorvar.SetName(name);
        vectorvar.SetDefinition(expression);
        vectorvar.SetType(Expression::VectorMeshVar);

        DEBUG("adding vector '%s' with expression '%s'", 
                    name.c_str(), expression.c_str());
        md->AddExpression(&vectorvar);
    }

    vector<int> cycles;
    GetCycles(cycles);
    md->SetCycles(cycles);
    //md->SetCyclesAreAccurate(true);

    vector<double> times;
    GetTimes(times);
    md->SetTimes(times);
    //md->SetTimesAreAccurate(true);
    md->SetTemporalExtents(0, GetNTimesteps()-1);

    addDerivedVariables(md, timeState);
}