Number of distinct connected digraphs with 4 vertices and 6 edges I have been looking at graphs representing how people or things can move between states (vertices).  Each directional move from one vertex directly to another is an edge, and each vertex must be reachable from every other vertex.
My question is "How many distinct graphs are there with 4 vertices and 6 edges?"  By "distinct, I mean that no graph can be turned into another by flipping, rotating, or re-labeling the vertices.
I would also appreciate pointers to the more general question of the number of distinct graphs that arise with V vertices and 2(V-1) edges.
 A: In the particular case of 4 vertices and 6 edges, we can generate them exhaustively.  I use some GAP code below.
Step 1: generate all labelled digraphs:
nrVert:=4;;
nrEdges:=2*(nrVert-1);;

LabelledDigraphs:=[];

DigraphBacktracking:=function(v,edgeSet)
  local deg,outNeighborSet,newedgeSet;

  for deg in [0..Minimum(nrEdges-Size(edgeSet),nrVert-1)] do
    for outNeighborSet in Combinations([1..nrVert],deg) do

      # loops are not allowed
      if(v in outNeighborSet) then continue; fi;

      # add new directed edges
      newedgeSet:=Concatenation(edgeSet,List(outNeighborSet,u->[v,u]));

      if(v<nrVert) then
        DigraphBacktracking(v+1,newedgeSet);
      else
        if(Size(newedgeSet)=nrEdges) then
          LabelledDigraphs:=Concatenation(LabelledDigraphs,[newedgeSet]);
        fi;
      fi;

    od;
  od;
end;;

# start backtracking
DigraphBacktracking(1,[]);

Then we filter out isomorphic representatives, which we can do by brute force (i.e., compute the entire isomorphism class) since the parameters are small:
# brute-force computes the isomorphism class; finds minimum
IsomorphismClassRepresentative:=function(edgeSet)
  local alpha,permutededgeSet,IsomorphismClass;

  IsomorphismClass:=[];
  for alpha in SymmetricGroup(nrVert) do
    permutededgeSet:=SortedList(List(edgeSet,e->[e[1]^alpha,e[2]^alpha]));
    IsomorphismClass:=Concatenation(IsomorphismClass,[permutededgeSet]);
  od;

  return Minimum(IsomorphismClass);
end;;

UnlabelledDigraphs:=Set(LabelledDigraphs,edgeSet->IsomorphismClassRepresentative(edgeSet));

Then I wrote a script to print them, giving the 48 digraphs drawn below:

For 4-vertex 4-edge digraphs, we get these four:

This agrees with Marko Riedel's answer in these cases.
A: The  following Maple  code  uses  Maple and  PostScript  to produce  a
diagram of  the $29$  unique graphs with  self-loops on  five vertices
having four edges. The image is shown below.

with(combinat);

PLOTG5E4L :=
proc()
local edges, choice, perm, orbits, orbit, uniqorbs,
    sl, loc, vertloc, looploc, fd, vert, line,
    prolog, rot, current, inst, edg;

    edges :=
    {seq(seq({p, q}, q=p+1..5), p=1..5),
     seq({p}, p=1..5)};

    orbits := table();

    for choice in choose(edges, 4) do
        orbit := [];

        for perm in permute(5) do
            sl := [seq(p=perm[p], p=1..5)];
            orbit :=
            [op(orbit), subs(sl, choice)];
        od;

        orbits[sort(orbit)[1]] := 1;
    od;

    vertloc := []; looploc := [];
    for rot from 0 to 4 do
        loc := exp(rot*2*Pi*I/5);

        vertloc :=
        [op(vertloc), [Re(loc), Im(loc)]];

        looploc :=
        [op(looploc), [Re(loc)*3/2, Im(loc)*3/2]];
    od;

    uniqorbs := [indices(orbits, 'nolist')];

    current := 0;
    fd := fopen(`noniso-g5e4l.ps`, WRITE);

    prolog :=
    ["%!PS-Adobe-1.0",
     "%%Creator: Marko Riedel",
     "%%Title: graph orbits",
     sprintf("%%%%BoundingBox: 0 0 %d %d",
             (1+4*4)*20,
             (1+4*ceil(nops(uniqorbs)/4))*20),
     "%%Pages: 1",
     "%%EndComments"];

    for line in prolog do
        fprintf(fd, "%s\n", line);
    od;

    fprintf(fd, "%%Page 1 1\n\n");

    fprintf(fd, "0.05 setlinewidth\n");
    fprintf(fd, "20 20 scale\n");

    for inst in uniqorbs do
        fprintf(fd, "gsave\n");
        fprintf(fd, "%f %f translate\n",
                2+4*irem(current, 4),
                2+4*iquo(current, 4));

        for edg in inst do
            if nops(edg) = 2 then
                fprintf(fd, "%f %f moveto\n",
                        vertloc[op(1, edg)][1],
                        vertloc[op(1, edg)][2]);
                fprintf(fd, "%f %f lineto\n",
                        vertloc[op(2, edg)][1],
                        vertloc[op(2, edg)][2]);
            else
                fprintf(fd, "%f %f moveto\n",
                        looploc[op(1, edg)][1]+0.4,
                        looploc[op(1, edg)][2]);
                fprintf(fd, "%f %f 0.4 0 360 arc\n",
                        looploc[op(1, edg)][1],
                        looploc[op(1, edg)][2]);
            fi;
        od;

        fprintf(fd, "stroke\n");

        for vert to 5 do
            fprintf(fd, "0 1 0 setrgbcolor\n");
            fprintf(fd, "%f %f 0.4 0 360 arc\n",
                    vertloc[vert][1], vertloc[vert][2]);
            fprintf(fd, "fill\n");


            fprintf(fd, "0 0 0 setrgbcolor\n");
            fprintf(fd, "%f %f 0.4 0 360 arc\n",
                    vertloc[vert][1], vertloc[vert][2]);
            fprintf(fd, "stroke\n");
        od;

        fprintf(fd, "grestore\n");
        current := current + 1;
    od;


    fprintf(fd, "showpage\n");
    fclose(fd);

    true;
end;


