cet-is » art

Here is a complicated FHiCL that utilizes the different kinds of structures that FHiCL supports:

pset: {

   flag: false
   tuple: [ 4, "some string", 6.5 ]
   vecOfVecs: [ [0,2], [4,5] ]

   funSeq: [ [ 1., 2. ], true, 2 ]

   tableSequence: [
      { a: "p1" 
        b: ["s1","s2" ] 
        tableSequence2: [
          { c: one },
          { c: two }
        ]
      },
      { a: "p2" 
        b: ["s3","s4" ] 
        tableSequence2: [
          { c: three },
          { c: four }
        ]
      }
   ]

   pset2: {
      test: this
   }

}

With the C++ FHiCL types, the above configuration could be supported with the following declaration in a user's source code:

 //============================================================================
  // Job configuration
  //

  struct PSet2 {
    Atom<std::string> test { Key("test") };
  };

  struct Test {
    Atom<int> value { Key("c") };
  };

  struct ForRootInput {
    Atom<std::string> primary { Key("a") };
    Sequence<std::string> secondaries { Key("b") };
    Sequence< Table<Test> > tablesequence2 { Key("tableSequence2") };
  };

  struct Configuration {

    Atom<bool> flag { Key("flag") };
    Tuple<int,std::string,double> tup { Key("tuple") };

    Sequence< Sequence<int> > vecOfVecs { Key("vecOfVecs") };
    Tuple< Sequence<double,2>, bool, int> funSeq { Key("funSeq") };
    Sequence< Table<ForRootInput>,2 > tablesequence  { Key("tableSequence") };
    Table<PSet2> pset2 { Key("pset2")};
  };

In order to provide a meaningful reference, the system must be able to register the following keys for validation of a parameter set:

pset
pset.flag
pset.tuple
pset.tuple[0]
pset.tuple[1]
pset.tuple[2]
pset.vecOfVecs
pset.vecOfVecs[*0]
pset.vecOfVecs[*0][*0]
pset.funSeq
pset.funSeq[0]
pset.funSeq[0][0]
pset.funSeq[0][1]
pset.funSeq[1]
pset.funSeq[2]
pset.tableSequence
pset.tableSequence[0]
pset.tableSequence[0].a
pset.tableSequence[0].b
pset.tableSequence[0].b[*0]
pset.tableSequence[0].tableSequence2
pset.tableSequence[0].tableSequence2[*0]
pset.tableSequence[0].tableSequence2[*0].c
pset.tableSequence[1]
pset.tableSequence[1].a
pset.tableSequence[1].b
pset.tableSequence[1].b[*0]
pset.tableSequence[1].tableSequence2
pset.tableSequence[1].tableSequence2[*0]
pset.tableSequence[1].tableSequence2[*0].c
pset.pset2
pset.pset2.test

where the [*0] represent placeholder indices for Sequence<T> objects, which can have an arbitrary number of elements. This will facilitate easier matching against the parameter set.