For OWL 2, there is a validator [1] that tells you which axioms are causing the ontology to be out of one of the OWL 2 sublanguages. It still contains bugs, but whenever I noticed a mistake, it was a false positive (some valid OWL 2 DL/EL/QL/RL ontologies are considered invalid by the validator).

[1] http://owl.cs.manchester.ac.uk/validator/

Firstly, I think that the question should better be restated as

"What are the reasons that an RDF graph fails to be a valid OWL DL ontology?"

Because the question does not really seem to be about OWL Full, which is a well-defined language with a particular semantics for interpreting (arbitrary) RDF graphs.

Now, the question why an RDF graph is not a valid OWL DL ontology is a complex one. But there is a single technical criterion that has to be satisfied by an RDF graph to be an OWL 2 DL ontology (better: an "OWL 2 DL ontology in RDF graph form"). Here is the criterion:

Given an RDF graph G,

1) G must be transformable by the reverse OWL 2 Mapping to RDF into an OWL 2 ontology S(G) in the OWL 2 Structural Specification; and

2) S(G) must satisfy all the conditions for being an OWL 2 DL ontology, as listed at the beginning of Sec. 3 in the OWL 2 Structural Specification document.

So, to give a set of concrete reasons for an RDF graph being outside of OWL 2 DL, one must take a closer look to both the set of transformation rules in the reverse RDF mapping as well as to the set of conditions for being an OWL 2 DL ontology.

Here is a -- very incomplete -- list for a start:

• A missing ontology header (e.g. as it is often the case for RDFS [non-OWL] vocabularies).
• Missing declaration triples for classes or properties (e.g. the name "ex:People" is used in a class subsumption axiom but there is no triple "ex:People rdf:type owl:Class").
• Incomplete OWL construct encodings (e.g. a missing owl:Restriction triple in a property restriction expression).
• Using entity types as normal entities in axioms (e.g. the axiom "dcterms:AgentClass rdfs:subClassOf rdfs:Class" in the DC vocabulary).
• Disregarding the separation of the object and data domain (e.g using the same property with both URIs and literals; or having both URIs and literals in an owl:oneOf expression; or using owl:sameAs with literals; or building inverses of data properties).
• For OWL 1 DL only: Using the same name for two entities of different entity types (e.g. as both an individual and a class). This is allowed in OWL 2 DL, though, by "punning".
• Having axioms on annotation properties beyond subsumption, domain or range axioms (e.g. disjointness of skos:prefLabel and skos:altLabel, as defined in SKOS).
• Using datatypes like classes (e.g. in class subsumption or disjointness axioms; equivalence is allowed in OWL 2 DL, however, in a restricted form).
• Using custom datatypes in literals (e.g. "3.0+4.0i"^^ex:complex).
• Using blank nodes in a non-treelike way (e.g. _:x foaf:knows _:y . _:y foaf:knows _:x .).
• Putting certain kinds of restrictions to "complex" properties, such as those defined by sub property chain axioms (e.g. when making the "uncle" relation an asymmetric property, where uncle is defined by the property chain "father o brother -> uncle").
• Using RDF lists as normal entities (e.g. ex:foo skos:memberList (ex:X ex:Y ex:Z)).
• Using logic OWL terms like normal entities (e.g. ex:hasInstance owl:inverseOf rdf:type; or ex:IdentifierProperty rdfs:subClassOf owl:InverseFunctionalProperty).
• Declaring a property as rdf:Property without additionally declaring it as one of owl:ObjectProperty, owl:DatatypeProperty or owl:AnnotationProperty (typical for RDFS vocabularies).

As stated in another answer, the Manchester OWL 2 Validator is an appropriate tool for detecting and reporting such issues. If I correctly understand, the Validator basically implements/checks the criterion for being an OWL 2 DL ontology presented above.

Any OWL DL document is OWL Full too. OWL DL puts restrictions on the OWL to make it compatible with description logic.